StrongLoop is excited to announce a new version of the LoopBack Android SDK 1.3. The release adds two new features: user authentication and storage service client.

What’s LoopBack? It’s an open-source API server for Node.js applications. It enables mobile apps to connect to enterprise data through models that use pluggable data sources and connectors. Connectors provide connectivity to backend systems such as databases. Models are in turn exposed to mobile devices through REST APIs and client SDKs.

User authentication

User authentication and authorization are important for many applications.  The LoopBack Android SDK provides classes that make it easy to connect an Android client app to a server application using LoopBack’s authentication and authorization model: User, that represents on the client a user instance on the server, and UserRepository.

To get started:

  • Enable authentication in your loopback server as described in the Access control tutorial.
  • Create an instance of UserRepository</code>: </span> </li> ```js RestAdapter restAdapter = // get the global adapter object UserRepository userRepo =     restAdapter.createRepository(UserRepository.class); ```
  • At application startup, find the currently logged-in user. When no user is logged in and your application requires an authenticated user, instead present the login screen Activity.
  • ```js userRepo.findCurrentUser(new ObjectCallback() {  @Override public void onSuccess(User user) {         if (user != null) {             // logged in         } else {             // anonymous user         }     } }); ```
  • Call the following method to log in a user:
  • ```js userRepo.loginUser("", "password",  new UserRepository.LoginCallback() {         @Override public void onSuccess(AccessToken token, User user) {             // user was logged in         }         @Override public void onError(Throwable t) {             // login failed         }     } ); ```
  • Use getCachedCurrentUser() in your Activity classes to get the data for the current user.
  • ```js User currentUser = userRepo.getCachedCurrentUser(); if (currentUser != null) {  // logged in } else {  // anonymous user } ``` Refer to the LoopBack Android SDK documentation for more information. ## **Working with files** SDK version 1.3 adds support for working with files using the LoopBack storage service.  The storage service makes it easy to upload and download files to cloud storage providers and the server local file system. It supports the following providers:
  • Amazon
  • Rackspace
  • Openstack
  • Azure
  • Server file system
  • Let’s illustrate the client API on a hypothetical application for submitting insurance claims. To submit a claim, one has to attach documents proving the validity of the claim, such as pictures of the damaged property. ## **Solution design** The LoopBack server will track claims using a `Claim` model. Supporting documents will be stored in a storage service.  There will be one container for every claim record. The Android application will enable user to view documents attached to a claim and to attach more documents. Refer to the blog post Managing Objects in LoopBack with the Storage Provider of Your Choice for instructions on how to setup storage service in your LoopBack application. ## **Creating a new claim** To avoid extra checks further down the line, the app will create the container when the user enters a new claim in the system as shown below: ```js ContainerRepository containerRepo = adapter.createRepository(ContainerRepository.class); containerRepo.create(claim.getId().toString(), new ObjectCallback() {     @Override     public void onSuccess(Container container) {         // container was created, save it         activity.setContainer(container);         // and continue to the next activity     }     @Override     public void onError(Throwable error) {        // request failed, report an error     } }); ```  

    Displaying  documents

    To display a list of documents that are already uploaded, we need to fetch all files in the container associated with the current claim as follows:

    ```js activity.getContainer().getAllFiles(new ListCallback() {     @Override     public void onSuccess(List remoteFiles) {         // populate the UI with documents     }     @Override     public void onError(Throwable error) {         // request failed, report an error     } } ``` To display the document, the app downloads its content and builds a `Bitmap` object that it can display on the Android device: ```js void displayDocument(File remoteFile) { File.DownloadCallback() {         @Override            public void onSuccess(byte[] content, String contentType) {             Bitmap image = BitmapFactory.decodeByteArray(content, 0, content.length);             // display the image in the GUI         }         @Override         public void onError(Throwable error) {             // download failed, report an error         }     }); } ```

    Attaching a new document

    To keep this example simple, we will skip details on how to take pictures in Android (for information on this, see the Android Camera docs). Once the picture is taken, the app uploads it to the storage service and updates the list of all documents: ```js camera.takePicture(     null, /* shutter callback */     null, /* raw callback */     null, /* postview callback */     new Camera.PictureCallback() {         /* jpeg callback */         @Override         void onPictureTaken(byte[] data, Camera camera) {             // A real app would probably ask the user to provide a file name             String fileName = UUID.randomUUID().toString() + ".jpg";             activity.getContainer().upload(fileName, data, "image/jpeg",                 new ObjectCallback() {                     @Override                     public void onSuccess(File remoteFile) {                         // Update GUI - add remoteFile to the list of documents                     }                     @Override                     public void onError(Throwable error) {                         // upload failed                     }                 }             );         }     } ); ```

    You can find more information in the LoopBack Android SDK documentation.

    ## **What’s Next?**
  • Download the SDK bundle for Eclipse:
  • See the Android SDK documentation.
  • Install LoopBack with a simple npm command
  • What’s in the upcoming Node v0.12 version? Big performance optimizations, read the blog by Ben Noordhuis to learn more.
  • Need performance monitoring, profiling and cluster capabilities for your Node apps? Check out StrongOps!