Android Small Talks: Backendless – an Alternative to Parse.com

Why do I choose Backendless as my MBaaS service?

Backendless provides us with a lot of functionalities, including:

• User Management,
• Data Persistenceter,
• Geolocation,
• Media Streaming,
• Publish/Subscribe Messaging,
• Push Notifications,
• Custom Business Logic,
• Analytics,
• Mobile Code Generation.

To enable connecting to the database, SDK was made available for both Android and iOS. However this is not the only method of connecting – we can also do it through the REST API, so everyone can choose whatever is most convenient to them.

Below I will explain the basic functionalities, such as user management, communication with a database, and own business logic.

User management

Backendless has a special table for users. It is automatically created for each new application. SDK provides special methods and classes that allow you to register new users and execute the logging process in an easy way.

We also have at our disposal a dedicated system that facilitates confirming having created a new account by sending its user an e-mail with an activation link.

Registration

User registration is very simple. SDK is provided with the class BackendlessUser, which has fields such as e-mail and password. Moreover, we can add any field by setting property passing key and value.

All queries using SDK are held by calling static methods of respective classes. In this case, it is our UserService class. For each query performed in the background, we pass an appropriate callback, which is called with a response from API.

public void registerUser(String username, String email, String password) {
        BackendlessUser user = new BackendlessUser();
        user.setEmail(email);
        user.setPassword(password);
        user.setProperty("username", username);

        Backendless.UserService.register(user, new AsyncCallback<BackendlessUser>() {
            @Override
            public void handleResponse(BackendlessUser response) {
            }

            @Override
            public void handleFault(BackendlessFault fault) {
            }
        });
    }

Logging in

Logging users in is handled in a very similar way to registration. We also use the UserService class. For logging in, we need an e-mail address used for registration and a password.

public void loginUser(String username, String password, BaseDataCallback<UserProfile> callback) {
        Backendless.UserService.login(username, password, new AsyncCallback<BackendlessUser>() {
            @Override
            public void handleResponse(BackendlessUser response) {
            }

            @Override
            public void handleFault(BackendlessFault fault) {
            }
        });
    }

Communication with a database

Backendless allows us to automatically map database tables to our classes. If our class has a name different than a table we need to add a call for the mapping method (preferably in the application class). For example:

Backendless.Persistence.mapTableToClass("BackendlessProduct", Product.class);

Now we can save and write data while performing operations on our objects. Once again, we will use static methods.

Saving product

public void saveProduct(Product product, BaseDataCallback<Product> callback) {
        Backendless.Persistence.save(product, new AsyncCallback<Product>() {
            @Override
            public void handleResponse(Product response) {
            }

            @Override
            public void handleFault(BackendlessFault fault) {
            }
        });
    }

Getting the product list

public void getProducts(BaseDataCallback<ArrayList<Product>> callback) {

        Backendless.Persistence.of(Product.class).find(new AsyncCallback<BackendlessCollection<Product>>() {
            @Override
            public void handleResponse(BackendlessCollection<Product> response) {
            }

            @Override
            public void handleFault(BackendlessFault fault) {
            }
        });
    }

For all tables in the database which were created by us, we use the Persistence class. It provides us with the methods necessary for table content management, such as save, remove, find, loadRelations.

Business logic

If we need to perform any additional operations on the database, e.g. when saving objects, Backendless will be of great help. For such purposes, there was made available a special module allowing adding code that is to be executed before or after a particular action. The selection of actions is quite large and includes removing objects, saving, and searching. We can write code for business logic in Java, PHP, or JavaScript.

A simple example may look like this:

@Asset( "Product" )
public class ProductTableEventHandler extends com.backendless.servercode.extension.PersistenceExtender<Product> {

  @Override
  public void beforeCreate( RunnerContext context, Product product) throws Exception {
    product.setDescription("This is cloud code generated description");
  }   
}

It is enough to extend the class PersistenceExtender, and then overwrite appropriate methods. In this case, it is a beforeCreatemethod, which, as the name suggests, is called before saving an object to a database. These methods can be performed synchronously or asynchronously. The configuration for each class is available in the developer panel.

To sum up, Backendless is an excellent choice for those looking for an alternative to Parse.com or simply an MBaaS service. Its main advantages are providing access to a database both by using SDK and REST queries and an option of writing your own business logic.