Hey folks, this post is the story about the development of dark mode feature in Vookmark Android app. We’re starting with a feature that we know you’re already excited about. We announced Dark Mode back in Jan and the response was huge so we know you’ve been waiting with bated breath ever since.

So we prioritised the feature in line with the high popularity. Instead of just adding some black backgrounds & flipping colours, we decided to restyle some of the modules for this Dark Mode, while still maintaining Vookmark’s look & feel. We’re very proud of how sexy this Dark Mode has come to be. 🤭

Why we introduced Dark mode feature in Vookmark?

In recent years, millions of Android users have been insisting on Google enable dark themes on their Android phones. So Google has added a dark mode in Android 9.0+, which not only looks cool, is easier on your eyes and helps you to save on battery life.

Google has started providing support for dark themes in all Android’s core applications. So we are also following Googles footprints, and no more frying your retinas at night time. Whether you’re a night owl who wants to give your eyes rest or you just want to change things up a bit, you’ll find something to love while watching the bookmarked videos at night. In fact, you can watch more videos because of better power management. Yay, it’s available right now on every platform — Android, iOS, and Web.

What are the ways to achieve this feature?

Theme changes use case is often in Android application development, that there is a setting, button or checkbox which can switch between different colour themes or between something like day and night mode. We can achieve this use case using one of the below solutions.

1. Recursively change attributes on all your Views:

This way, when the theme is changed, you can loop through all the Views, again and again, to change the attributes to reflect the new theme.

public void recursiveViews(ViewGroup parent) {

  for (int i = parent.getChildCount() - 1; i >= 0; i--) 
  {
       final View child = parent.getChildAt(i);
       if (child instanceof TextView) {
           (TextView) child).setTextColor(...);
       } else if (child instanceof Button){
           (Button) child).setTextColor(...);
       } 
         // ... check other views
  }

}

As it’s not about changing two or three colours in the main views, in order to keep your code clean, it’s better to do the changes on the XML files and not dynamically via Java code. Loop through all the views will decrease the app performance, increase the loading time and the code complexity.

2. Duplicate layouts for each of your themes:

By creating the separate layouts for every theme for a single screen and set the layout as content view while initialising the activity.

LightThemeLayout:

<RelativeLayout
    ....
    android:background="@color/windowbackgroundLight">
    <TextView
        android:id="@+id/stats_provider"
        android:textColor="@color/textColorPrimaryLight" />
</RelativeLayout>

DarkThemeLayout:

<RelativeLayout
    ....
    android:background="@color/windowbackgroundDark">
    <TextView
        android:id="@+id/stats_provider"
        android:textColor="@color/textColorPrimaryDark" />
</RelativeLayout>

LayoutSwitchingActivity:

public class HomeActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) 
  {
      super.onCreate(savedInstanceState);
   
      if(isDarkMode) 
          setContentView(R.layout.activity_home_light);
      else
          setContentView(R.layout.activity_home_dark);
   }
}

The only difference between each layout is that the style or in-line style-related attributes. This will increase the number of layout and code duplication while adding screens for every theme. This approach is very simple however, it will increase the code complexity. Same time it will increase the APK size as well because of the number of layout files.

3. Changing the theme at runtime(*Recommended solution*):

To make it work, We have to create separate Styles, by sharing the same base. A Style is a reusable form of a collection of resources. By the way, A theme is also a collection of resources which modifies look and feel of your product. The minor difference is you apply theme on a bigger level, say a screen(Activity) and you usually apply style on a granular level, say a view(Button, TextView..).

Here are the actual styles for the home activity:

<!-- Light theme -->

<style name="BaseActivityThemeLight" parent="ActivityTheme.Primary.Base.Light">
    <item name="android:windowBackground">#FFFFFF</item>
</style>

<!-- Dark theme -->

<style name="BaseActivityThemeDark" parent="ActivityTheme.Primary.Base.Dark">
    <item name="android:windowBackground">#000000</item>
</style>

Applying a different theme that, the one specified into the manifest file must be done before calling the parent onCreate() method.

public class HomeActivity extends AppCompatActivity {

  @Override
  protected void onCreate(Bundle savedInstanceState) 
  {
      super.onCreate(savedInstanceState);

      if(isDarkMode) 
          setTheme(R.style.BaseActivityThemeDark);
      else
          setTheme(R.style.BaseActivityThemeLight);

      setContentView(R.layout.activity_home);
  }
}

This approach is a bit complex because we have to define the themes for the individual views based on the application style. It will decrease the code complexity since we reuse the layouts as it is. Same time a granular level of increase in the APK size.

How we achieved it?

In line with Android’s own guidelines, we’ve kept things clean and simple in Dark Mode with proper use of colour and by using the material design theming guidelines.

We achieved this feature by changing the theme at runtime based on the user's style selection.

How to enable/disable the Vookmark app’s new Dark Mode?

To turn on the feature, the obvious first step is to make sure that you have the version of Vookmark (v3.2.7) or above.

Once the update installs, it’s just a matter of tapping the Settings from the slider menu, the “Dark Mode” toggle is under the theme settings. It’s disabled by default, and activating it will cause the page refresh. However, Vookmark returns with an easy-on-the-eyes dark theme. It’s not completely black, we still maintaining Vookmark’s look and feel.

What is next?

We hope you’ll like our new dark look and enjoy our Vookmark service even more. In the meanwhile, we’ll be working on what’s next for Vookmark.

Now that we’ve implemented flexible Dark Mode, go wild — we can switch themes automatically based on the time of day or based on the system-wide dark mode setting.

Didn’t grab Vookmark yet?

Vookmark is a place to collect all your favourite videos in one place. Ever stumbled upon an awesome video and cannot watch it immediately? Vookmark solves that problem too. Keep a permanent collection of video links you love and watch them everywhere.

Vookmark allows you to add videos easily from top video platforms like YouTube, Facebook, Vimeo, DailyMotion, Reddit. You can watch all your videos on Vookmark for Android, Web, iPhone, iPad or Apple TV.

Get started with Vookmark.

Hope this post will help you to get your head around Dark Mode and its Android implementation.

Please continue to share your feedback and suggestions to us on team@vookmark.co and help us to spread the word about Vookmark on social media with #vookmark and tagging @getVookmark as well as in real life!

In-app purchase (IAP) is a great way to earn money from your Android app. IAP is mostly used to unlock some additional features in your app that you want to monetise from. Monetisation is one of the most important aspects of distributing your product to the rest of the world. Like it or not, Google charges 30% of each successful transaction that your app will make.

Based on the available API’s we can classify IAP products into two types.

Managed in-app products:

Products are managed by the developer, you can decide if you want to handle your managed products as non-consumable or consumable items.

• Consumable product: It is usually temporary and, once consumed, can be bought again, For example, the user’s in-game character might gain life points or gain extra gold coins in their inventory.
• Non-consumable product: It can only be purchased once in your application and provide a permanent benefit. Once purchased, these products will be permanently associated with the user’s Google account. For example, upgrading an app to pro version, or removing ads

Subscriptions:

A payment that will unlock features of your app for a limited amount of time(days, weeks, months, years). Billing continues indefinitely at the interval and price specified for the subscription. When a subscription is not renewed, the product is no longer active for the user.

With this tutorial, you will learn everything that you need to know about In-App Purchases. I will try to be as much detailed as possible, and will break down this tutorial to multiple steps for better understanding:

Let’s begin!

1. Adding the Play Billing Library to your app
2. Configuring products
3. Implementing Purchase helper to your app
4. Get purchase history
5. Get product details
6. Initiating a Google Play In-app Billing Purchase
7. Redirects to Manage Subscription
8. Cancel an active subscription

After implementing this IAP in multiple projects, I thought why not this be done with a single util class. So I’ll explain the above-mentioned steps using the helper class.

1. Adding the Play Billing Library to your app:

Just add the following dependency in your project.

implementation ‘com.android.billingclient:billing:1.1’

Add internet permission in your AndroidManifest.xml file. Embedded billing permission inside the library’s manifest. It’s not necessary to add the com.android.vending.BILLING permission inside Android manifest anymore.

<! — To use internet → <uses-permission android:name=”android.permission.INTERNET” />

<uses-permission android:name=”android.permission.INTERNET” />

… sync your project.

2. Configuring the products:

In order to have the IAP within your app, you must first configure your in-app products using the Google Play Console. Since this article is more oriented towards play-billing library implementation, I won’t get into too much detail about how to configure the products. I suggest you read this by yourself from the official documentation because it’s quite self-explanatory with examples too.

Create a managed product
Create a subscription

Sounds easy enough, right?

3. Implementing Purchase helper to your app:

To implement our PurchaseHelper util into your app, you need to declare and define the object with the callback interface (PurchaseHelperListener), which will give you the response of your specific query. You can use the following code snippet

PurchaseHelper purchaseHelper;

purchaseHelper = new PurchaseHelper(this, getPurchaseHelperListener());

public PurchaseHelper.PurchaseHelperListener getPurchaseHelperListener() {

return new PurchaseHelper.PurchaseHelperListener() {

@Override

public void onServiceConnected(int resultCode) {

Log.d(TAG, "onServiceConnected: " + resultCode);

}

@Override

public void onSkuQueryResponse(List<SkuDetails> skuDetails) {

}

@Override

public void onPurchasehistoryResponse(List<Purchase>  purchasedItems) {

purchaseHistory = purchasedItems;

}

@Override

public void onPurchasesUpdated(int responseCode, @Nullable List<Purchase> purchases) {

Log.d(TAG, "onPurchasesUpdated: " + responseCode);

}

};
}

4. Get the purchase history

Before launching the billing flow we have to check the status of the product, to check the history of the purchase. You can make the request to get all the already purchased items. You can achieve this by making a simple function call

// You can pass BillingClient.SkuType.INAPP || BillingClient.SkuType.SUBS purchaseHelper.getPurchasedItems(TYPE);

It will return the response of this request into our callback function onPurchasehistoryResponse(List purchasedItems). From this, we can get all the purchases in the specific SkuType which is connected with the specific app and the Google account which is active in the device Google play.

5. Get the product details

To show the details about the products, we have to get the details from our play console using the product ID. For this, we have to pass the list of product IDs and the SkuType. You can get the product details by using the following snippet.

purchaseHelper.getSkuDetails(skuList,BillingClient.SkuType.INAPP);

It will return the response of this request into our callback function onSkuQueryResponse(List skuDetails);.

6. Initiating a Google Play In-app Billing Purchase

To initiate the In-app Billing Purchase, you have to pass SkuType and the product ID

purchaseHelper.launchBillingFLow(BillingClient.SkuType.INAPP, getProduct_id());

It will return the response of this request into our callback function onPurchasesUpdated(int responseCode, @Nullable List purchases). We can implement the logic here to consume the purchased item.

7. Redirects to Manage Subscription

To manage our subscriptions, in the earlier days, we could redirect the users only to the Play Store on your app’s page and the user have to figure out where to click next to cancel the subscription. But now In 2018 I/O, the play billing team included a nice add-on, that we can easily redirect the user to the “Manage subscription” page for your app.

You can do this by using the following function call, the single line makes your life easier.

purchaseHelper.gotoManageSubscription();

8. Cancel an active subscription:

In Android, Currently, the Google Play Billing library does not provide support for programmatically cancelling subscriptions from inside the purchasing app. It is only available within the Play Store app.

We can cancel the subscriptions via Google Play Developer API. To cancel the subscription we need the following parameters

1. The package name of the app
2. Purchased subscription ID
3. PurchaseToken provided to the user’s when the subscription was purchased.

As a developer, we never like to provide an option to cancel the subscription. But this will be more useful to the user. If the user likes our app and the subscribed feature, then they will never use this option. If the user cancels a subscription, it will remain valid until its expiration time.

Bonus tip:

The renewal period will vary from 5 to 30 minutes, depending on the original billing period. In addition to this, previously they are limiting the number of times a test subscription can be renewed only 6 times, now it is unlimited.

Code:

The sample app is very simple and it covers almost all common use cases, doesn’t consider all the use cases you will need in your app; keep that in mind before loading the copy-paste machine gun.

The source code is available on GitHub,

One more thing to do, before executing the project you have to change the “applicationId” in the build.gradle(app) and also the “product_id” in the city_list.json file which is in the assets folder.

That’s it, now you can run the project, and voilà! It works like a champ.

Let me know how your IAP implementation went in the comments below. Now you can implement IAP into your app and start generating some revenue by selling your app.

Originally published at droidmentor.com on September 28, 2018.

Enjoyed the story? Leave some claps 👏 here on Medium and share it with your friends. Want to stay up-to-date on the latest in Android app dev? Follow me on Twitter. I won’t spam your feed. 😄

Jaison Fernando (@jaisonfdo) | Twitter

What is Vookmark?

There are many bookmark managers like pocket but we don’t have something specific for videos.So we decided build one and that’s the reason for Vookmark’s existence.

Most of the bookmarking services store just the url and redirect you when you visit their dashboard. Vookmark allows you to watch all videos in one place without messy redirections.

Why we choose subscription business model?

The subscription business model is one of the best ways to make more regular, reliable, and recurring revenue for multi-platform apps. In fact, both developers and users love subscription apps.

This monetisation strategy is very similar to one known as Freemium (Free to Premium). “Try first, then buy” — this is the key principle we followed in Vookmark. The app is free to download and offers some basic features but locks out premium features, which need to be purchased to extend the app’s functionality.

Why we choose Google Play In-App Subscription for Android?

I guess you have a doubt that, why we implement multiple payment sources(Google-play, AppStore and Stripe) for a single app. We wants to provide the hazel free experience to our users, during this free to premium transition and also we have couple of reasons for this Google play in-app subscription implementation, they are listed below

1. Google Play provides several subscription specific reports in the Google Play Console. It contains acquisition report, retention report, cancellations report.
2. Google Play also enables you to offer 3-day free trials (rather than previously a minimum of 7 days). From this our users are perceiving the value of the premium service.
3. Google Play lets you offer multiple payment options across countries with a trusted, reliable, and easy 2-step checkout process.
4. Google play provides Real-time developer notifications feature, it informs you of any change in subscriber state in real time, such as cancellation or suspension, so you can act on the information immediately.
5. Google Play now makes restoring a subscription much easier with the new subscription restore feature. Using this feature user can restore the cancelled subscription until the expiration date.

Google play In-app subscription implementation:

Google provides an easy to use library that is able to handle the subscriptions and querying tasks. In this library, Google Play provides a straightforward, simple interface for sending In-app Billing requests and managing In-app Billing transactions.

While implementing In App Subscriptions we found that the process of implementing it was not that complicated, but there were some hidden facts that took us time to figure out. It deserves a separate tech blog post. We are planning to write one soon. Keep watching this space for updates.

How we achieve multi-platform payment process using Google play In-app subscription?

When the user made a successful purchase request, we will get a receipt for a particular transaction, we are just forwarding this receipt payload to our Vookmark server and validating it in the server.

For this validation, Google provides receipt validation through the Google Play Developer API, within the API, there are two endpoints: Purchases.products: get and Purchases.subscriptions: get.

In our case we are using Purchases.subscriptions: get is for verifying and re-verifying auto-renewing product subscriptions. To use this API we must know the packageName, productID and purchaseToken all of these can be found in the receipt payload we received during purchase.

We need an access token which we can get by creating a Google API service account. To get started with a service account go to the Google play Developer console API access settings page and Link your project with the service account, which will help us to validate the purchase detail using Google play Developer API.

Write once, run anywhere

Though we used multiple payment mediums for payment process, but we consolidate everything in our server. So the payment triggering point is different, order receipt payload is different, the validating mechanism is also different, but we clubbed everything together and make it as a unified payment platform and provide the seamless experience to our users across all platforms.

For detailed Backend Integration check this medium post by one of our team member.

How we manage payments across multiple platforms in Vookmark 🤑💸

Give a try and enjoy the seamless cross platform application for video bookmaking at Vookmark.

Happy Vookmarking ! 😎

Happy Earning! 🤑

This article is a part of How to setup CI & CD for Android series. In my previous article, I described CI & CD and also explained the automation process.

In this article, I’m going to explain setup process of Jenkins server and Gitlab account. I’ll cover this entire implementation on macOS.

Step 1 : Jenkins server setup

Jenkins server is available for download on their official site. Alternatively you can install Jenkins using homebrew (brew install jenkins). At the end of the installation, it will automatically redirect your browser to http://localhost:8080 which is the local address of your Jenkins.

In the first launch you will need to unlock Jenkins, using the initialAdminPassword, because only admin can access the secrets directory. For more details regarding this basic setup, please take a look here.

Finally, your Jenkins instance is up and running now!

Note : The Jenkins user has been created (/Users/Shared/Jenkins) by default. So keep in mind that all files and variables declared under the default user will not be visible for Jenkins. To resolve this issue, your Android SDK needs to be installed in one of the shared folders like /usr or /opt.

To implement CI/CD automation process, you have to install the following plugins on Jenkins server by using Manage Jenkins > Manage Plugins

1. Android Emulator Plugin
2. Git Plugin
3. Gradle Plugin
4. Android Lint Plugin
5. Android Signing Plugin
6. Fabric Beta Publisher
7. Google Play Android Publisher Plugin

After the successful installation of the above listed plugins, restart the Jenkins server.

Step 2 : Gitlab configuration :

To configure Gitlab with Jenkins, a common user account needs to be created. Log in to the Gitlab server as an administrator. After that create a repository to store your codebase in GitLab and change it with version control.

In Gitlab you can create repositories with Public/Private access. Anyone can access the public repositories with the remote URL. If you have a private repository you need to create an ssh key for your Jenkins and add it to your GitLab.

Before you dive deep,.. make sure Jenkins Server and Gitlab Account are already setup and running.

Step 3 : Integrate Gitlab with Jenkins:

For this integration, first create a SSH key pair to access the private repository, after this you have to add our public key as a deploy key to our Gitlab account and add the private key as a Jenkins Credential.

1. Adding your public key as a deploy key in Gitlab, go to your Gitlab Profile Settings >SSH Keys and add an SSH Key

2. Then add your private key as a Jenkins credential. For this go to Jenkins server, Jenkins > Credentials > System > Global Credentials > Add Credentials

3. Next, Jenkins needs your Gitlab API access token to get the metadata from Gitlab. To create the access token, go to your Gitlab Profile Settings > Access Tokens and create an Access token.

4. Add the above created access token as a Jenkins credential. For this create a API token credential using Jenkins > Credentials > System > Global Credentials > Add Credentials.

5. Once the API Access has been setup, we can configure the connection between Jenkins and GitLab. To make this happen go toJenkins > Manage Jenkins > Configure System > Gitlab Section and create a connection by using the above added GitLab API token

Finally, we have completed the basic Jenkins set up and now we are ready to create our First Job for a CI and deployment process. So lets start the same without much delay.

Step 4 : Basic job setup

For job creation, go to Jenkins > New Item and now enter a valid Job title and select FreeStyle Project.

In the General Section give the project name and select our connection(above created) as GitLab connection and all the other fields there are self explanatory.

In the Source Code Management Section, place your repository URL(SSH), select the above added SSH Jenkins credential and select a particular branch for this job or leave it empty. I would recommend not to leave it as empty.

Step 5: Configure Jenkins — Build Triggers :

In this section, select the build triggering events based on our requirement(in our case we have to trigger this build generation on every push and every merge request).

Then create a secret token from Advanced tab, it will be used, while setting up the webhooks in Gitlab.

Step 6: Configure Jenkins — Post-Build Actions

Next thing what we have to do is configuring the post action of the project build completion. For this example, we have to add an action to change the commit status as Completed.

That’s it, now we completed the Jenkins setup, at next we need to do the GitLab setup to trigger the build for every push and every merge request. For this we can use webhooks.

Step 7: Configure Gitlab Webhooks :

To create a webhooks we need our Jenkins URL and secret token. For creating these webhooks, go to your repository Integration Settings and do the changes, which is mentioned in the below image.

Note: By default Jenkins runs on your local machine. To make it available from the outer world you need to deal with services like Heroku or AWS. If you want something really simple and fast here is a tool called ngrok available. Two steps installation allows to create a tunnel to your localhost and generate a secure public URL.

Once we complete the above mentioned steps, now we can change the gitlab commit status into passed/completed without human intervention.

Now everything should be set! If you push a commit / make a merge request to the repository, you should see the Jenkins job start running. Once the job completes, you should see the status next to the commit in GitLab.

What’s next?

In the next part of this series, we will be focusing on Android Build Configuration & Automation process. See you in next post!.

Hope to see you again soon.

Enjoyed the story? Leave some claps 👏 here on Medium and share it with your friends. Want to stay up-to-date on the latest in Android app dev? Follow me on Twitter. I won’t spam your feed. 😄

Jaison Fernando (@jaisonfdo) | Twitter

Check all the top articles at http://droidmentor.com/

This is the first part of a series of articles that will give you a complete walkthrough for setting up a CI & CD environment for your Android projects.

In small projects, developers can do tasks manually with regards to building projects, testing and deployment. When the project grows exponentially it will become a big headache.

Automate more, so you do less.

As a developer, your aim is to automate as many processes as possible. Work hard in order to work less. In our case by setting up a CI system you can ship updates more often and with less (zero) effort on your part.

So, what is a Continuous Integration?

Continuous Integration (CI) is the process of automating the build every time a team member commits changes to version control.

There are plenty of continuous integration platforms, some you can set up on your own machine while the other offer cloud-based solution.

Now, continuous integration is clear (I hope so) we can move to Continuous Deployment.

Continuous Deployment (CD) is a strategy for software releases and CI is a building block of this process.

How it works?

1. Developers check the code locally and commit changes to the repository.
2. Repository sends a request (web-hook) to CI system
3. CI server runs job, which will generate a build and run tests to ensure your code works as expected.
4. Finally deploy the APK file to production(Google Play Store)

This is how the process roughly looks like:

Sounds good? Awesome. Let’s do this…

A good build process makes everyone’s lives easier. As an example we will use the following services for our build and distribution process.

Services Used:

Source control : GitLab
CI server : Jenkins
Build distribution : Beta by Fabric

Gitlab + Jenkins + Fabric Beta = Awesome!!

For the automation process of a traditional Android workflow, we’ll use the above mentioned services and glue them together. But before we go there, we need to take them one by one, and see what they do.

GitLab:

GitLab is a git hosting solution with a very large toolset. It is completely free for unlimited users, unlimited private repositories, and full access to most of the awesome features they provide.

Jenkins:

Jenkins is an open source automation server, more specifically a continuous integration server. Jenkins is the longtime ruler of the CI/CD space. It provides hundreds of plugins to support building, deploying and automating any project.

Beta by Fabric:

Fabric Beta is the App distribution tool. The distribution process is much easier than other services. Also It provides a nice UI dashboard to manage the builds and invite the users/testers.

All we need to do is add an email address of the user in the Fabric account for a project and they will get an Email notification whenever the developer creates a new build.

Steps for an awesome build process:

1. Setup Jenkins server & Gitlab
2. Android Build Configuration & Automation
3. Distribute builds with release notes to test users via Fabric Beta
4. Automated Deployment

What’s next?

In the next part of this post, we will be focusing on the Jenkins server setup and the Gitlab setup for this automation process.

Enjoyed the story? Leave some claps 👏 here on Medium and share it with your friends. Want to stay up-to-date on the latest in Android app dev? Follow me on Twitter. I won’t spam your feed. 😄

Jaison Fernando (@jaisonfdo) | Twitter

Check all the top articles at http://droidmentor.com/