How to implement in android

How to Quickly Implement Beautiful Charts in Your Android App

Mar 1, 2019 · 7 min read

People mostly perceive information visually: videos, photos, and charts draw attention and explain things better than plain numbers or words. This is why many applications use bright and clear charts to present information. In this article, we explore how to add charts to your app without spending lots of time (and therefore money) on their development.

Why and where should you use charts?

Charts have become an extremely popular element of modern UI design in mobile applications. There are lots of ways you can use them in your application, and there are even more ways you can make your charts sleek and beautiful.

Char t s have benefits that make this way of presenting information one of the best:

• Visual — According to multiple studies, people perceive visual information much better than any other kind of information. For example, a study by researchers at the University of Minnesota showed that people process visuals 60,000 times faster than text. This means that adding a chart to your mobile app will make information clearer and therefore improve the user experience.
• Optimize space — A chart can also be a compact way to present information. Instead of using tables, just implement charts and free screen space.

You can use charts to display lots of information. For example, Apple uses charts in the Apple Watch to show fitness information.

You can also use charts in a banking app or an app for managing personal finances to show spending and income:

Charts can be used in apps for mobile analytics and marketing:

And there are countless cases where you can use charts in your mobile app. These types of applications often use charts:

• Banking and personal finance
• Fitness and nutrition
• Analytics
• Logistics
• Social media
• Battery management
• Time management
• Internet of Things
• Business and management

You can find lots of creative ways to use charts in other types of mobile applications as well.

Now let’s talk about how to implement a chart in your mobile application and not spend lots of development hours on it.

A simple solution for your app

Creating a chart using graphics can take lots of time, prolonging development and increasing costs. To avoid this, you can use an open source library to create charts. There are already lots of them online, and you can choose any. In this article we’ll look at MPAndroidChart by Phil Jay. It’s new in comparison to other chart libraries, and I like it because it’s stable. Over 3,000 users on GitHub agree with me. With this library, you can create different kinds of customizable charts without much effort. You can also add animations and customize them.

Now I’ll show you how to draw charts on Android with this library. In this article we’ll focus on a simple bar chart with animation, but first let’s explore what types of charts are available in this library.

MPAndroidChart Library

All you need to know about MPAndroidChart is that it’s one of the simplest ways to add charts to your app and that it works on Android API 8 and above. If you want to use animations, you’ll need API 11 or above.

Animations are a core element of modern mobile app UIs, which is why it’s such a great thing to have them in this library. You’ll find over 25 built-in animations, but if you want something special you can also add custom ones. So what can you actually build with MPAndroidChart?

• Simple bar chart
• Grouped bar chart
• Horizontal bar chart
• Simple line chart
• Line chart with cubic lines
• Grouped line chart
• Combined line and bar chart
• Pie chart
• Scatter chart
• Candlestick chart
• Radar chart

In this tutorial, we’ll build a grouped bar chart with animation like the one shown here:

How to integrate an animated chart step by step

Step 1

To start, first add these lines to your gradle file:

Step 2

Create a layout for your MPAndroidChart:

As you can see in the above layout, I’ve used the com.github.mikephil.charting.charts.BarChart xml tag to create an Android bar chart.

Step 3

Now have a look at the activity code:

This will result in a great-looking bar chart like this:

Let me explain how the MPAndroidChart library works. As shown in the class above, first a BarChart is initialized. Then data is generated according to the bar chart with the help of the BarEntry class. This is a subclass of the Entry class, which is the base class for all chart data types in the MPAndroidChart library.
Further, this BarEntry is added into BarDataSet. Then all of these values along with X-axis values are set in the bar chart using the chart.setData(data) method. Now to make the bar chart reflect this latest data, we need to call chart.invalidate()method. This will result in the great-looking bar chart shown above.

As I’ve mentioned, the MPAndroidChart library is customizable. Let’s have a look at some of its key features.

MPAndroidChart animations

To animate a chart from the MPAndroidChart library, these methods are used:

• chart.animateX(2000) — For X-axis animation
• chart.animateY(2000) — For Y-axis animation
• chart.animateXY(2000, 2000) — For XY-axis animation

The above code will add a standard animation. But if you wish to change the animation style or want to make a custom animation, refer to this page. Note that animations will work only on API 11 and above.

MPAndroidChart colors

While making charts on Android using the MPAndroidChart library, you can also change the color of bars in the chart using these methods:

• setColor — Used to set a single color for a full data set
• setColors — Used to set entries in different colors within a data set

These methods are used while creating the DataSet object shown above.

Conclusion

MPAndroidChart is a great library that can help developers create beautiful, customized, and animated charts in just a few steps. In this article I showed you how to build a bar chart, but you can create all kinds of charts for your application — just change the class names. Mostly you won’t have to change anything: the MPAndroidChart library is created in such a way that in all charts you input the information in the same way.

If you have any questions on integrating or using charts in your mobile app, don’t hesitate to contact Mobindustry for a free consultation. We’ll be glad to help.

Источник

How to Implement and Use a Parcelable Class in Android: Part 1

Welcome! First of All… We need some Context!

Creating a Parcelable class is a vital skill for Android Developers because it allows you to pass an object from one Activity to another. This series will walk you through step by step in the process of implementing a parcelable class and using it in a simple App. Let’s get started! 👍

Real-World Scenarios 🌐

To give some you context of why we need to learn how to make class parcelable, I will use a scenario I faced during my Android Developer Nanodegree when I developed an App that displays data for popular movies from The MovieDB API.

• When I made a request to the API, Movie objects were created. The Main Activity displayed all the posters and ratings of the movies but if the user clicked on a movie poster, a new Activity had to be launched to display the movie’s data.
• I had already made an API request and in order to avoid making another one I made the class Movie a parcelable class. This way I could efficiently transfer the object I had created in the Main Activity to the Details Activity.

Parcelable Behind the Scenes!

When an object is parcelable, we can pass it to another Activity. This Activity then recreates the object so we can access its attributes and methods.

Now Let’s go to the Code! 💻

Step 1: Creating the Project

First we create a new Project in Android Studio with MainActivity , DetailsActivity and our Parcelable class, House (Let’s pretend we’re building an app for a real state company)

Step 2: Implementing Parcelable

When we first open the House class, we see the class definition.

We make this class implement Parcelable (It will display a warning until we implement the necessary methods)

💡 Tips: You can implement the methods automatically by clicking Alt + Enter (on Windows) while your cursor is on the code that displays the warning, as shown below:

There are only two methods we need to implement ( describeContents and writeToParcel ):

After we click OK, we see that there is still a warning being displayed in the Class name:

Press Alt + Enter again (on Windows) to add the Parcelable Implementation

Customizing the Class

We now have our class but we need to add attributes. Notice the first constructor in the class below. You may ask: How can we add attributes to a constructor that now takes a Parcel as argument? Let’s find out!

Custom Attributes

We will first add variables for the attributes:

💡 Tips: I’ve chosen these attributes to demonstrate how each data type is written and read to and from the parcel).

Custom Constructor

We will add a custom constructor to create instances as we normally do.

Now for the Fun Part, Writing to the Parcel!

When we launch the destination Activity, our object will be written to a Parcel using this method that we already created in the class in the previous steps:

For most data types we use this syntax to write the attributes to the parcel (Android Studio will display the options available):

💡 Tips: The syntax may vary depending on the data type such as with the Boolean attribute nearSchool . To learn more about how to write and read Booleans in a Parcelable class, please refer to my article: 👍

How to Read and Write Booleans in a Parcelable Class

This is the class we will be working with, House. It has a Boolean attribute, isNearSchool . Take your time to go…

Now Let’s Read from the Parcel!

The constructor below is the one we will use to read from the parcel when our object is received in the destination Activity. Have you noticed that it takes a Parcel as a parameter? This is the parcel we will read from.

The general syntax to read from the parcel is:

⚠️ WARNING: It is extremely important to highlight that you must read the values in the same order that they were written in writeToParcel ⚠️

This is our finished Class! 👍

💡 Tips: You can automatically create getters and setters in Android Studio by Clicking on Alt + insert or by going to code -> Generate

Continue to Part 2 👋

In the next article of this series we will cover How to pass a parcelable object between Activities using a very simple Android App as demo. See you there! 😃

Источник

How to implement In-App Updates in Android using Kotlin

There’re two ways to show an update inside your app:

• Flexible: A popup appears, asking the user if they want to update the app. They can accept or deny it. If they accept it, the update will download in the background. This can be used when your update has some minor UI changes or performance improvements.

• Immediate: This is a full-screen UX that requires the user to update the app to continue using it. This can be used when you have a critical update, like a security fix.

You can trigger the update with two signals:

• Priority: In each release, you define how important the update is by giving an integer that goes between 0 and 5 (5 being the highest priority). This will trigger the right update flow (Immediate or Flexible) to update the app.

• Staleness: Says how long the device has known about an update been available. This helps you to trigger the right flow. For example, if the user hasn’t updated the app the last 30 days since the release of the update, then trigger the Flexible flow, and if it’s longer than 90 days, trigger the Immediate flow.

You can also combine both signals for a better user experience, and this is what we’re going to implement in this tutorial.

Adding library

Go to your app-level gradle.build file, and add the following dependencies:

We need the material library to show a snackbar when the update has been completed when we’re using the flexible flow.

Implementing in-app update

To make it easier to implement, we’re going to add all the things we need in a different file, and then we’re going to call it from the Activity we want to check for the updates.

Create a new file, name it InAppUpdate, and paste the following code inside:

In your Activity (usually is the MainActivity), initialize the InAppUpdate class, and add the methods onResume and onActivityResults:

Using this code, when you set priority to:

5: Shows Immediate instantly (Recommended for critical updates)
4: Shows Flexible after 3 days and Immediate after 5 days
3: Shows Flexible after 15 days and Immediate after 30 days (Recommended for performance updates)
2: Shows Flexible after 30 days and Immediate after 90 days (Recommended for minor updates)
1: Shows Flexible forever
0: It doesn’t trigger any update flow

Of course, you can change the code the way you like to fit your needs.

To set the priority for the update, you need to do it through Google Play Developer API, and there’s no option to do it from the Google Play Console (yet).

Instead of using the Google Play Developer API, we’re going to use the Gradle Play Publisher. It’s a Gradle plugin that automates the process of publishing an app on the Google Play Store, and we can set the priority for our release from inside the Android Studio.

NOTE: The Gradle Play Publisher only works for apps that have already been published on the Google Play Store. If you haven’t published it yet. You have to do it through the Google Play Console and then use the Gradle Play Publisher for the next releases.

Before we start with this, we need to have a key(.json) file, that we’ll get after creating a Service account in Google Play Console, and the Keystore(.jks) file.

Creating a Service Account in Google Play Console

In Google Play Console, go Settings > API Access press Choose a project to link, and then I agree

Next, go Create new project and press the Link project button

Press Create new service account and open the Google Cloud Platform

In Google Cloud Platform, press + CREATE SERVICE ACCOUNT

Give it a name, and press CREATE

In the next step, select Owner as a role (don’t worry, we’ll remove it later), and press Done

Press the 3 dots on the right side, and press Create key

On the new window, select JSON and CREATE

Rename the .json file to a simpler name, like key.json, and save it in your computer (or in the cloud, like Dropbox, because we’re going to add it in the .gitignore later and every time you download your project from version control, you need to add it back in your project manually)

Now, go back to Google Play Console and press Done

Next, go to the Users and permissions section and press Invite new users

Open the .json file you downloaded before (key.json) with a text editor, copy the email from “client_email” and paste it inside the Email address.

Then, press Add app and select your app from the list

On the new window, select the followings and press Apply

With these permissions, we’ll be able to publish our apps for testing and production using the Gradle Play Publisher.

Next, press Invite user

Now, it’s time to remove the Owner permission we added previously.

Go back to Google Cloud Platform, select the IAM section from the left sidebar, and press the pencil icon to edit the account

On the new window, press the trash icon to remove the permission and then SAVE

Done! We created the service account!

Now let’s copy the key(.json) and the Keystore(.jks) file into our project.

Adding your Service Account and Keystore files in your project

Go to your project’s folder, and inside the app folder, paste the key(.json) and the Keystore(.jks) file:

Next, to edit the .gitignore, we need to unhide the hidden files, press Cmd + Shift + . (dot) and open the file with a text editor (e.g., VS Code), and add the following lines (the .jks lines might be already there, just uncomment them)

We’re doing this because when you have your app on version control, and it’s not a private repo, then everyone can have access to your Google Play Developer account.

Gradle Play Publisher

Adding the plugin

Go to your app-level gradle.build file, and at the top of your file:

If you’re using the plugins DSL, add:

If you’re using legacy plugin application, in your top-level build.gradle file add:

And then, in your app-level build.gradle add:

Setting up the plugin

In the app-level build.gradle file, inside the android < >, and before buildTypes add:

Inside the buildTypes, add:

And after buildTypes, add:

Replace the storePassword, keyAlias, and keyPassword with your own keys.

Next, if you want to include Release Notes with your release, create a .txt file with the name of the track (e.g., internal.txt, beta.txt, etc.) and paste it inside:

(your project name)/app/src/main/(create a folder and name it play)/(create a folder and name it release-notes)/(create a folder and name it with the language of the release notes, for example, en-US)

Testing

To test your in-app update implementation, you need to upload your app on the internal (or alpha or beta) track, twice.

Go to your app-level build.gradle file, increase the versionCode and the versionName, set your track, and press Sync Now

Then, open the Terminal inside the Android Studio and type ./gradlew publishBundle to publish a bundle.

If you want to publish a .apk, type ./gradlew publishApk

See more details about Gradle Publish Plugin’s terminal commands here

Now, go to your Google Play Console to see the release in the track you set before (Mine is the ‘internal’ track)

Select the Testers tab to add your testers

Press Create email list and add the email address you have on your phone with Google Play Store installed.

Then press the Copy link and open it from your phone to have access to the internal track.

After installing your app through the internal track, do the same steps we did (increase versionCode, upload with the Gradle Play Publisher, etc.), but now, set a number for the priority of the update.

Go to Google Play Store on your phone and check if your app has an update (DO NOT update it from there).

Close the Google Play Store and open your app to see the in-app update.

From now on, this is the way that you have to upload your app (through Gradle Play Publisher). If you upload it from Google Play Console, the app won’t trigger any in-app update flow to the users.

If you have any questions, please feel free to leave a comment below

Источник