Npm platform add android



Hey there,

I created a nativescript-vue app using this command:

vue init nativescript-vue/vue-cli-template

But now i want to use an Android library, and thus googled how to do so in Nativescript.
This article was the best match but unfortunately Brad used a command that I could not

tns platform add android

I tried npm platform add android but had no success…
Is there a way to add a platform to a nativescript-vue project or is there any other way of using Android libraries?

Kindest regards,


Just add the dependency to your gradle file inside app resources, it should be then available for you to access at run time.


Well the adding of the Android lib worked, thanks :smiley:
Unfortunately though my NativeScriptApplication has to Implement BootstrapNotifier because for my project I have to use RegionBootstrap.

How can I do this?


Refer docs here


The link you provided is for non-vue projects (as usually :sob:).

I do not know whether I’m using an old webpack.config.js but I do not quite fully understand what I should modify in order to make the extending work.

This is my webpack.config.js(unmodified)

const path = require('path');
const webpack = require('webpack');
const winston = require('winston-color');
const CopyWebpackPlugin = require('copy-webpack-plugin');
const ExtractTextPlugin = require('extract-text-webpack-plugin');
const OptimizeCssAssetsPlugin = require('optimize-css-assets-webpack-plugin');
const WebpackSynchronizableShellPlugin = require('webpack-synchronizable-shell-plugin');
const NativeScriptVueExternals = require('nativescript-vue-externals');
const NativeScriptVueTarget = require('nativescript-vue-target');

// Prepare NativeScript application from template (if necessary)

// Generate platform-specific webpack configuration
const config = (platform, launchArgs) => {`Bundling application for ${platform}...`);

  // CSS / SCSS style extraction loaders
  const cssLoader = ExtractTextPlugin.extract({
    use: [
        loader: 'css-loader',
        options: {url: false},
  const scssLoader = ExtractTextPlugin.extract({
    use: [
        loader: 'css-loader',
        options: {
          url: false,
          includePaths: [path.resolve(__dirname, 'node_modules')],

  return {

    target: NativeScriptVueTarget,

    entry: path.resolve(__dirname, './src/main.js'),

    output: {
      path: path.resolve(__dirname, './dist/app'),
      filename: `app.${platform}.js`,

    module: {
      rules: [
          test: /\.js$/,
          exclude: /(node_modules)/,
          loader: 'babel-loader',

          test: /\.css$/,
          use: cssLoader,
          test: /\.scss$/,
          use: scssLoader,

          test: /\.vue$/,
          loader: 'ns-vue-loader',
          options: {
            loaders: {
              css: cssLoader,
              scss: scssLoader,

    resolve: {
      modules: [
      extensions: [

    externals: NativeScriptVueExternals,

    plugins: [

      // Extract CSS to separate file
      new ExtractTextPlugin({filename: `app.${platform}.css`}),

      // Optimize CSS output
      new OptimizeCssAssetsPlugin({
        cssProcessor: require('cssnano'),
        cssProcessorOptions: {
          discardComments: { removeAll: true },
          normalizeUrl: false
        canPrint: false,

      // Minify JavaScript code
      new webpack.optimize.UglifyJsPlugin({
        compress: {warnings: false},
        output: {comments: false},

      // Copy src/assets/**/* to dist/
      new CopyWebpackPlugin([
        {from: 'assets', context: 'src'},

      // Execute post-build scripts with specific arguments
      new WebpackSynchronizableShellPlugin({
        onBuildEnd: {
          scripts: [
            ... launchArgs ? [`node launch.js ${launchArgs}`] : [],
          blocking: false,


    stats: 'errors-only',

    node: {
      'http': false,
      'timers': false,
      'setImmediate': false,
      'fs': 'empty',


// Determine platform(s) and action from webpack env arguments
module.exports = env => {
  const action = (!env || !env.tnsAction) ? 'build' : env.tnsAction;

  if (!env || (! && !env.ios)) {
    return [config('android'), config('ios', action)];

  return && config('android', `${action} android`)
    || env.ios && config('ios', `${action} ios`)
    || {};


Vue or Angular or Core doesn’t make any difference, you are just going to create a JS / TS file and import it.