The rules were pretty simple – we have to demonstrate our product, we had for it only 5 minutes, but as opposed to other similar events – there is no Power Point rule. So it was a little bit challenging to show the complexity of Mobeelizer in an easy way, so that everybody understand it, and in the same time doesn’t have the feeling that is a simple app. 

We had a brain storm in the office before the event – what should we present, because obviously it couldn’t be raw development and it shouldn’t be our Demo App available in App Store, Google Play or Windows Phone Store. At the end we decided to show how to write simple mobile offline client to the highly popular CRM Pipedrive.

Armed with the ready sample and trained many time presentation, which was divided between me and Bartek, we entered the place of the event. It was based in coworking office mobilesuite and the place was astonishing – full of simple design and sophisticated ideas. That kind of places is one of the thing that I envy people from Berlin.

During that evening five companies beside us presented their products:

• Auctionata http://auctionata.com
• Credport http://www.credport.org
• Paymill http://www.paymill.com
• Skobbler http://www.skobbler.com
• SnapEngage http://www.snapengage.com

All of them were amazing – both products and the show, but for me the the most interesting was Auctionata – they are really disrupting the old fashioned industry of art auction and the technology that they’ve made was really astonishing.

Returning to our presentation – we wanted to show how a regular developer is working with Mobeelizer – from the idea to working prototype. As I mentioned – it was challenging to do it in 5 minutes, but we did it showing nearly live coding during it. What was the schedule:

• How to define the data model in AppDesigner and setup Users
• How to download the ready made project template for iOS
• How to use ORMapper in the iOS app to display and save data to local SQLite database
• What to do in order to synchronize with Mobeelizer cloud from the mobile app
• How to connect Mobeelizer with Pipedrive in order to exchange data in both ways.

Ufff, quite a lot We had some troubles during it – mainly with the poor internet connection, but we made it.

It was an amazing evening, full of networking, beer and good food. We had also small interview for Gruenderszene. The good thing for all of our Mobeelizer community is, that in few days we will release on our blog the tutorial „How to make an offline mobile client for Pipedrive CRM”.

This is a significant milestone for our docs, because so far there was no complete information how to create your own conflict resolver. In this new tutorial we based on Java Advanced Tutorial, which shows how to create simple web application with two models, how to work with users roles and how to synchronize web application database with Mobeelizer. In the new tutorial we added new tool for web application, which is displaying modification history of conflicted entity. The new tool also lets administrators select correct version of entity to resolve conflict. Everything is created in Spring roo, so to complete this tutorial you have to be familiar with:

• JAVA language
• Basic of Spring roo (see)
• Key concepts of Mobeelizer platform (see) especially conflicts.

What you need to do now is complete Java Advanced Tutorial and skip to Java Conflict Resolving Tutorial. When everything gets done, you should be able to see conflicted records and to resolve them. 

 It is not a surprise. The mobile applications help us everyday in daily life, so it was to be expected that sooner or later the applications will help us in work life. In a few short years, mobile devices have emerged as a critical new platform for business computing. So, I apply to companies whether you planned or not, you can be forced to build a mobile version of system, which you are working on already.

 In this year, there are going to be 3 trends in enterprise applications:

Firstly, there is going to be a trend to shift data towards to the cloud. It is the best move for companies to cooperate better and exchange data easier between employees, partners and customers. Cloud and mobile technology deliver a completely new opportunity for enterprises, efficiently deliver company’s data to mobile workers. Cloud and mobile service will become more important than ever in enabling the enterprise workforce. It is important for companies to pick the right cloud service from a list of suppliers, which cuts IT cost and add some features as well.

 Secondly, by the developing trend of BYOD (Bring-Your-Own-Device), building application on only one platform is pointless. It is necessary to look around for mobile development platform, which allows build an application on several operating systems.

 Last but not least trend is that the integration is going to be a priority. Almost every enterprise mobile application will place an emphasis on connection to back-end system and synchronization to company’s CRM system or any other system of records. Not only is there important provide useful data but also enable complete transaction.

 Looking ahead, it will become easier for employees to use their phones to access and exchange data from corporate email, spreadsheets, Power Point presentations or PDF reports. Of course it will be impossible to replace PCs entirely, but increasing popularity of mobile devices are changing the way of how businesses look like lately.

 Everything sounds good for me, because Mobeelizer allows companies to keep securely their data in the cloud, allows develop multi-platform applications and it’s main feature is that it allows to synchronize data easily between mobile devices, but as well between mobile device and web or desktop application.

 It’s going to be a year of business apps, a year of Mobeelizer

A native application is an app program that has been developed for using on the specific device platform. Users purchase it from online stores or marketplaces and install into their devices. The native app responds more quickly than a mobile web app, because the interface is more direct. The advantages, which distinguish the native app are:

• work offline
• synchronization with device resources
• use push notification
• increased safety with no exposure to browser bugs
• ease of installation
• work in the background
• cooperation with other applications
• full use of the hardware device

A web mobile application is accessed though the mobile device’s web browser and it doesn’t need to be installed on the device. The advantages of this app are definitely different:

• accessibility
• cost-effectiveness
• similar functionary to the website
• use via web browser
• compatibility with all platforms/OS
• easy upgradability
• update content in real time
• ease of sharing between user via send simple link.

But both of these applications have got some weakness too. The biggest disadvantage of the native app is its costs. Not only is developing for different platforms more expensive but also maintaining multiple code bases. Releasing once in while new versions of the app is costly as well. Moreover, app store can delay the launch of the app or prevent the release of the app, which carries huge risk.

In the case of mobile web app the biggest disadvantage is that there is no possibility to get an access to all of device’s features. Additionally, users must be always online.

Furthermore, the research conducted by Yahoo! and Ipsos shows that more people are using web mobile app mostly to shop, search or entertain. It presents as well that if the goal is primarily concentrated on marketing or if the aim is to deliver the content or establish mobile presence, the mobile website is a logical choice. On the other hand, if the aim is to connect, navigate, inform or manage something, than it is more likely to reach for native app.

Taking these pros and cons into the consideration and depending on the usage of applications, it seems to me that there is no best choice. It’s all about context. If your mobile application is mainly used to display and interact with online content or services, avoid the native choice. But, if your app is mostly used offline, a native app will offer a better user experience.

As I said at the beginning, the dispute as to, which application is better, is pointless. If you wonder, which application is better for your business, first you should analyze the aim of application and the target.

Our company – Mobeelizer is concentrated only on native application. It supports businesses to make many processes easier by synchronizing their data into mobile devices.

What I want to tell you is that you have to be very careful before you choose between Open Source and Closed Source products. You have to get familiar with the benefits of both solutions. Mobeelizer’s SDKs are distributed under GNU Affero General Public License. In this article, I would like to show you benefits of fact that Mobeelizer’s SDKs are Open Source, but it won’t be a simple list of them. I would like to give you real world examples how to reap this benefits.

Costs

Really often Close Source solutions updates are expensive. Imagine that you are using stable version of some SDK and in next release there will be 10 new features available. For your business only one of them is important, but you have to pay for all of them. Mobeelizer updates are always for free. You can download version of your choice and modify it anytime you want.

Bug fix waiting time

Mobeelizer provides free support for all of the SDKs, if you find bug that blocks the opportunity to further develop of your software, you can report it and we will fix it as soon as posible. Here is the great benefit for you. You don’t have to wait for next iteration to get the bug fix. You can download the code from github repository and build it just by yourself. Any extra time won’t be lost. Because we are using github to share our code our users can also fix bugs by themselves and simply send us pull-request.

Vendor lock-in problem

Who make the decision about next release? You whether your vendor? Imagine the situation when you found some bugs in bought SDK, you reported them but your vendor delays fixing them. You have to release new version of your product but you can’t. You also can’t resolve issues by yourself because SDK is closed.  Of course you can use SDK from different Vendor in that case, but what when engine of your solution base on that SDK? In Mobeelizer that problem is not becoming because SDKs are open source and you can change for example just Rest Client and still using OR Mapper. You can also fix bugs by yourself, you are not addicted to Mobeelizer support team.

Testing costs

This benefit is for you as great as for Mobeelizer. Because Mobeelizer SDKs are Open Source, many developers, who in the future may not be Mobeelizer clients, are analyzing usability of SDKs. What is it mean for you? More tests equals better quality. This kind of testers have also excellent impact for usability improvement.

Scalable in both directions

Imagine that you have just started using Mobeelizer. You downloaded the latest version of our SDK. While developing, you noticed that you don’t use features from last release, which weights pretty much. There is no problem to downgrade the version to save a few KB of application weight. And remember, it does’t cost at all.

Licences do not limit or restrict who and how can use the software

Mobeelizer’s SDK for mobile platforms was created to support differential synchronization using Mobeelizer HTTP API. Inside the SDK there are a few technologies used. There is OR Mapper based on XML mapping, there is also Mobeelizer Rest API client. You can use this SDK as you want, there is no problem to use it just as OR Mapper or just as tool to send data to the cloud. It is your choice and Licence permit you to do that.

On Mobeelizer github profile there is a few Open Source project for you. You can find there SDK for three most popular mobile platforms: Android, iOS and Windows Phone 7. There is also Java SDK which you can use for web applications, desktop applications or any others that base on Java. If you need to create your own SDK in any other technology you can also find there real world example how to use our HTTP API.

Lately, I found out that there is a video from this event and Marcin is presenting only 3 minutes pitch about our baby. Presentations during Seedcamp event can’t be longer, so there is time to focus only on 5 points.

- What is that you are doing?

- For whom is your solution?

- Who is your competition?

- Why are you better than your competitors?

- What do you expect from from Seedcamp?

Enjoy watching it!

You noticed that your application encounters some issues. But how to protect your application? You could prepare appropriate design, do some automatic or manual tests and so on. Ok, these are good things to do before the release time, but what should you do after your application goes live into production environment? I am pretty sure that you have prepared good architecture with all stability and capacity patterns in mind, but what about crashes and some unexpected failures?

There are many tools and solutions that provide monitoring of applications. You could i.e. prepare some external tools like: live check by http request (web applications) or log file scraping by some CRON script. But one of my favourite is to prepare embedded mechanism, which follows user activities, but in the same time is fully transparent for them. You could build this kind of mechanism with LogDigger - tool that helps you to collect and classify detailed error reports and logs for your Java applications. More about LogDigger you can find on this page.

In this tutorial, I would like to show you how to create appropriate solution to collect your application error logs with LogDigger. Moreover I will describe how to send these error logs spotted by LogDigger to your Zendesk, so you can automatically manage your application bugs in an organized way.

Add LogDigger jars to your application

First you should Download LogDigger Connector and copy jar files to your application’s WEB-INF/lib.

Add LogDigger servlet filter to application’s web.xml

com.logdigger.connector.ErrorLogStore;

public class ZendeskErrorLogStore implements ErrorLogStore {

    private JdbcErrorLogStore jdbcErrorLogStore;

    //errors to ommit before storing
    private String[][] ignoredErrors;

    //Mandrill API URL
    private WebResource webResource;

    //Mandrill API KEY
    private String mandrillApiKey;

    //LogDigger URL
    private String logdiggerAddress;

    @Override
    public void init(AttributeProvider attributeProvider) {
        jdbcErrorLogStore = new JdbcErrorLogStore();
        jdbcErrorLogStore.init(attributeProvider);

        ignoredErrors = new String[][] {
            {
                "com.someCompany.SomeException"
            }
        };

        mandrillApiKey = String.valueOf(attributeProvider.getAttribute("mandrillApiKey"));
        logdiggerAddress = String.valueOf(attributeProvider.getAttribute("logdiggerAddress"));
        webResource = Client.create().resource("https://mandrillapp.com/api/1.0/");
    }

    @Override
    public void destroy() {
        jdbcErrorLogStore.destroy();
    }

    @Override
    public ErrorLog getErrorLogById(String id) {
        return jdbcErrorLogStore.getErrorLogById(id);
    }

    @Override
    public ResultsPage<ErrorLog> findInDateRange(Date fromDate, Date toDate, int offset, int limit) {
        return jdbcErrorLogStore.findInDateRange(fromDate, toDate, offset, limit);
    }

    @Override
    public ResultsPage<ErrorLog> findSimilar(ErrorLog sample, int offset, int limit) {
        return jdbcErrorLogStore.findSimilar(sample, offset, limit);
    }

    @Override
    public ResultsPage<ErrorLog> getErrorLogs(int offset, int limit) {
        return jdbcErrorLogStore.getErrorLogs(offset, limit);
    }

    @Override
    public LastStoreError getLastStoreError() {
        return jdbcErrorLogStore.getLastStoreError();
    }

    @Override
    public int getMaxCategories() {
        return jdbcErrorLogStore.getMaxCategories();
    }

    @Override
    public String getStoreDescription() {
        return jdbcErrorLogStore.getStoreDescription() + " + ZenDesk extension";
    }

    @Override
    public boolean isAvailable(Feature feature) {
        return jdbcErrorLogStore.isAvailable(feature);
    }

  @Override
    public String save(ErrorLog errorLog) {
        if (errorLog.getCategorySignature(0).startsWith("com.mobeelizer.")) {

            // ignore all Mobeelizer exceptions
            return null;
        }

        //ignore all given exceptions
        for (String[] ignoredError : ignoredErrors) {
            for (int i = 0; i < ignoredError.length; i++) {
                if (ignoredError[i] == null) {
                    return null;
                }
                if (!ignoredError[i].equals(errorLog.getCategorySignature(i))) {
                    break;
                }
                if (i >= ignoredError.length - 1) {
                    return null;
                }
            }
        }

        //persist error log in DB
        String id = jdbcErrorLogStore.save(errorLog);

        //omit bug report if bug was reported
        if (jdbcErrorLogStore.findSimilar(errorLog, 0, 1).getTotalCount() == 1) {
            try {

                //create bug report content (stack + LogDigger console link)
                String content = (logdiggerAddress + "/console/view?err=" + id + "\n\n" + errorLog.getStackTrace()).replaceAll(
                        "[\n\t\r]+", "\\\\n");

                //create bug report subject
                String subject = "LogDigger " + errorLog.getLogSnippet().split("\n")[0];

                //Mandrill API to send mail
                WebResource path = webResource.path("messages/send.json");

                //create builder to send bug report
                Builder b = path.type(MediaType.APPLICATION_JSON_TYPE).accept(MediaType.APPLICATION_JSON_TYPE);

                //create Mandrill email message
                String s = ("{'key': '" + mandrillApiKey + "', 'message':{'text': '" + content + "', 'subject': '" + subject + "', 'from_email': 'no_reply@mobeelizer.com', 'to':[{'email': 'helpme@mobeelizer.com'}]}}")
                        .replaceAll("'", "\"");

                log.info(" logdigger: " + s);

                //report bug
                ClientResponse response = b.post(ClientResponse.class, s);
                if (response.getStatus() != 200) {
                    log.warn("Mail sending error - status: " + response.getStatus() + ", content: "
                            + IOUtils.toString(response.getEntityInputStream()));
                }
            } catch (IOException e) {
                log.warn(e.getMessage(), e);
            }
        }

        return id;
    }

Maybe some of you, who read us, don’t know what actually OR Mapper is, so at the beginning, I should make a short description. OR Mapper is programming technique consisting of mapping relational data structures to objects. The mapping is usually carried out by prepared frameworks that allow developers to use a relational database as if it was object-oriented.

Even if this technique has some disadvantages like additional overhead or limited functionality, on the other hand, it has cache, which has a positive impact on a productivity and a developing application can focus on a business logic.

On the market, there you can find many different OR Mappers like androrm, ORM-droid, aBatic ect., but I would like to concentrated only on 3: OrmLite, greenDAO and Mobeelizer and compare them.

greenDAO is a open source project, which is created to help Android dvelopers to work with stored data in SQLite database. greenDAO is mapping Java’s objects to database table. Even though greenDAO is a open source project, greenRobot (the company, which created greenDAO) provides commercial support for special customer requirements. The most important aims of greenDAO are:

• maximum productivity;
• easy to use API;
• highly optimized for Android;
• minimum memory usage.

OrmLite provides some simple, lightweight functionality for persisting Java objects to SQL databases while avoiding the complexity and overhead of more standard ORM packages.  It supports a number of SQL databases using JDBC and also supports SQLite with native calls to Android OS database APIs.

Mobeelizer is especially a platform for data synchronization between differ mobile platforms. Currently, it supports the most popular: Android, iOS and Windows Phone7. The main objective of Mobeelizer was to create relatively simple SDK to use in order to save not only data but also technical fields for synchronization. Sources are available on GitHub.

Below, I attached one task which has been shown during the presentation. The task is about finding all employes named Nowak and earning more than 5000zloty.

greenDAO:

List<Employee> employees = employeeDao.queryBuilder())
                         .where(EmployeeDao.Properties.Surname.eq(surname), 
                                EmployeeDao.Properties.Salary.gt(minSalary)).list();

OrmLite:

List<Employee> employees = database.getEmployeeDao().queryBuilder()
    .where().eq("surname", surname).and().gt("salary", minSalary).query();

Mobeelizer:

List<Employee> employees = Mobeelizer.getDatabase()
    .find(Employee.class).add(MobeelizerRestrictions.and(
         MobeelizerRestrictions.eq("surname", surname),
         MobeelizerRestrictions.gt("salary", minSalary))).list();

To sum up, if the developing application is light and fast, the best OR Mapper to use is greenDAO, but unfortunately the problem appears when the database is complicated.

For the complicated questions OrmLite is the best in spite of the relatively large size of the library.

So the question arises, why did we create own OR Mapper?

As I wrote at the beginning that one of OR Mappers’ disadvantage is that their functionality is limited. That’s why we have to keep additional metadata related to entities, because it’s a differential synchronization. It means that you can sync only these data, which have been changed from the last synchronization. In order to have whole control over this, we decided to create own OR Mapper.

Topics of presentations during the conference were diversified. There has been mentioned about Scala for Android, which is useful tool for solving Android problems or Continuous Integration on Android, where TDD and BDD techniques has been showed or even REST on Android.

Our presentation was about OR Mappers on Android platform. Tomek, our speaker, talked about advantages and disadvantages of OR Mappers, presented a few of them, chose 3 and compared to each other. It was the first presentation of Tomek in front of such a large audience. But everyone admitted that he had coped with it very well.

Details about the whole presentation I will show you in the next post. Stay tuned

Probably To-do application is used by everyone and describing it is pointless, but I would like to say few words about this one made on Mobeelizer platform.

To Do application is one of the basic applications for scatterbrained. It’s a organizer for task list, which forgetful person needs to accomplish.

Nowadays, you can download various types of this application, but only using Mobeelizer you are able to share your To-do list with colleagues and give them different permissions like in this tutorial. As a creator of assignment, you are able to add new task, delete and update them. Your friend as a user is able to receive whole tasks, but not able to edit them. If you finish any task from the list, both of you will be allowed to make them complete.

Sounds like a really necessary application. Especially when you can share your duties with someone else

OK, so now a To-do list for you:

1. Design simple model in App Designer.
2. Deploy our application on the test environment.
3. Configure app on the mobile.
4. Use our API to synchronize with Mobeelizer.

If you have some problems, write us asap and we will solve them for you