Tag Archives: NativeScript

NativeScript Android Snapshots

For those who haven't deployed any apps in v2.4 of NativeScript; one of the new features that is turned on by default is SnapShots.    Now most the time this is a AWESOME thing, however occasionally this can cause issues.   For example I have one app of mine that this crashes at startup when using SnapShots.

Now the docs do list how to disable snapshots; but it is a lot easier for me to find the notes on my own site than trying to figure out which doc has the info.

The environmental variable you need to adjust is: <strong>TNS_ANDROID_SNAPSHOT</strong>

  • 0 = Force Snapshots off always
  • 1 = Force snapshots on (including in debug mode)
  • Unset = Snapshots only in Release mode

Allowing TypeScript to understand NativeScripts ~/ home path

I know a wide number of you use TypeScript; well one of the irritations I've had with TypeScript -- I just figured out how to solve.   Finally did some research and tests to figure out how to make TypeScript support using ~/ as a normal path for building and determining editor intellisense since this is a special path in NativeScript meaning the home app path.   Using this path in a import / require statement means you can do something like this.

/app/views/login/login.ts ->

import * as animation from '~/support/animation'
and it will load in the file at   /app/support/animation

You can use relative paths, but I find absolute path's a lot easier to read and understand exactly which file is being loaded.   In addition things like my NativeScript-Updater can't use relative path's (do to some low level issues in the iOS runtimes) and determine if a file has been updated.

Ok, so the solution: open your tsconfig.json file and add the following:

"baseUrl": ".",
"paths": {
   "~/*": [

To the "compilerOptions" key in the json file.

NativeScript 2.4.0 - New Features

ns-version240Some of you might have seen the all New version 2.4.0 has been released today.   This has been a release that has taken a bit of time to get right, but it is finally out!  Wooo Hoooo!!!

Some of the new features

  • NativeScript Workers
  • Per-Side borders
  • Flexbox layout
  • Android Snapshots on Release build (faster app start time)
  • Added "import" to point to the JS file
  • More pseudo selectors: button now supports: pressed, active and highlighted, and views descendants support disabled.
  • Segmented Bar now has a new css property:  selected-background-color
  • TabView now has new CSS properies: tabTextColor, tabBackgroundColor, selectedTabTextColor, and androidSelectedTabHighlightedColor
  • Some CSS properties now support % sizes:  height, width, margin-left, margin-top, margin-right, margin-bottom, margin.
  • Image Capture allows rotation.
  • Camera module now a plugin (Removes a permission)
  • Brand new Theme!
  • Reduce the size of the Android App
  • Much nicer Android crash screen
  • Faster tns prepare
  • Android has ~ 97% support for pure ES6 code.
  • Can create TypeScript typings automagically on android platform using --androidTypings command line.

Lots and lots of bug fixing in all the repo's.

Upgrading (Core):

First of all to upgrade is done is a couple steps:
> npm install -g nativescript@latest
> npm install tns-core-modules@latest --save

For Android:
> tns platform remove android
> tns platform add android

For iOS
> tns platform remove ios
> tns platform add ios

Then you can type tns info and verify that everything says v2.4.x

Common Issues:

  • iOS failing to build, older projects:  v2.4 requires you to have the Info.plist file in the app_resources/ios folder.    The simplist way to fix this is to create a new project and then replace your app_resources with the new app_resources folder.  If you have any resources you have manually added or any changes to any files make sure you copy them out before you delete the old app_resources folder.  I would highly recommend you do NOT merge them as you might get some weird behavior from the old resources in the old format vs the new resources in the newer layout.
  • iOS requires CocoaPods v1.0 or later.   This is not a NativeScript issue so much as the Cocoapod infrastructure no longer allows anything older than 1.0..
  • Android failing to build with some plugins (like NativeScript-Telerik-Ui). with the error Multiple dex files define Landroid/support/v4/accessibility
  • Android failing with snapshot error, install the nativescript snapshot support via
    npm install nativescript-dev-android-snapshot@latest --save-dev
  • TNS no longer building your TypeScript files or livesync'ing any of your TS files.


NativeScript - Professional post series

I've been doing NativeScript for a while; and since I'm a contractor/freelancer; and no specific company pays my salary -- I've decided to start putting some of my cool learned tips into the paid category.   Most of these will only qualify if they took me multiple hours to figure out.  Unfortunately nobody pays me for fixing things when they break...  So, if I can use my hard earned knowledge to save you a vast amount of time, what is it worth to you?
All this knowledge is time tested and can save you a vast amount of diagnostic time on why something doesn't work.   So if you think saving you time is worth it; please feel free to sign up and support me; and I will provide the information you need when you need it...
The different series are going to be available on my Patreon site: https://www.patreon.com/NathanaelA
The first series is; NativeScript Platform Differences

You might get an app running perfectly on one platform, and then wonder why it isn't working on the other.   I have started out with a cool post on several issues you might have between iOS and Android using HTTP/HTTPS.

The second series is: Troubleshooting your NativeScript
I have started this series out on dealing with Upgrading from NativeScript  to 2.4 and issues you might face.
The first post in this series deals with a specific iOS upgrading issue.
The second post in this series deal with a specific Android upgrading issue (Error starts with: Multiple dex files), when using several plugins...
The third series is: Ready to Distribute my app...  What now?
The first post in this series deals with a specific iOS Build issues...
The second post in this series deals with a specific iOS Build configuration information.
Some of these posts will be showing up in the next couple day as I have time to finish them off...
And yes; I will continue to post free useful stuff...   😉

NativeScript - Workers

ns-workersOne of the best new features in the brand new 2.4.0 release of NativeScript is WebWorkers.    For those who have seen me around in the community; you will probably all know how long I have been harassing the NativeScript Core Teams to get this done (Since Aug of 2015).  I even went so far as to create a plugin (NativeScript-WebWorkers) that allowed you to spin up more JS threads but with the major limitation that they didn't have access to the native OS side of things, they were only pure JS.    So getting real 100% NativeScript webworkers this release means I am a VERY happy camper!

The feature is fully cross platform (i.e. works on iOS and Android) and allows you to spin up additional JavaScript engines to do all your heavy lifting needs in the background.    Now obviously, the more you spin up the more memory and cpu you will use; so you want to treat them as a precious resource and only spin up those you need.   Let me re-iterate; use these for only heavy duty processes; each worker is another FULL JS engine, which takes a chunk of memory and cpu to just start and maintain.

They still have full access to the iOS and/or Android runtime just like normal.   The only difference between them and the main thread is that you do not have any valid access to the GUI or GUI elements.   You can attempt to modify the GUI, but you will crash your app as you are not allowed in even in a native app to modify the GUI outside the main thread.  Same rules apply to a NativeScript app.

The NativeScript Core Teams modeled the background threads after the web workers model.  They are created, developed and destroyed the same way as a browser web worker would be.   So lets dig in.

Everything is passed via messages between the workers and the main thread; so lets look at a sample demo:

main file

"use strict";
exports.onNavigatingTo = function(args) {
   let myWorker = new Worker('./myWorker.js');
   myWorker.onmessage = function(msg) {
     console.log("Hi I'm a message from the worker: ", msg.data);
     myWorker.terminate();  // We no longer need the worker around, so kill it.
   myWorker.onerror = function(err); {
      console.log("Opps, something went wrong in the worker", err.message);
   setTimeout(function() { worker.postMessage("a Cool Message"); }, 500);

"use strict";
global.onmessage = function(msg) {
  console.log("Got a message form the main thread!", msg.data);
  postMessage("Worker's cool Message");
  // global.close();  // If ran, this would close the worker from inside.

global.onerror = function(err) {
  console.log("We can handle our own errors too", err.message);

Now as you can see we have two files; the first file is from the main thread it starts the new worker by doing let myWorker = new Worker([path to worker script]); this is how you start a brand new worker.   The new worker will load that JavaScript file and start it up.  Now there are some gotcha's we are going to cover on the worker side that you will want to know about.

  1. You want to require('globals'); as your first or second line.    If you do NOT require the global module, you will not have access to console, setTimeout , setInterval, and any other function you are used to using globally.   So requiring this function is pretty important for most workers.
  2. When you assign .onmessage (or .onerror if you are using it) you must assign them to the global variable.  The new version of the Android engine is enforces "use strict"; properly and having implied "this" variables is NOT allowed.  So as a habit when assigning something to the global scope; implicitly use global.
  3. All messages have a .data parameter that contains the data you sent from the other side.  When you do a postMessage({cool: "wow", I: "am"}); this will be in msg.data.cool and msg.data.I in the onmessage message.  This might catch you, but is easily fixed.  Please make sure that any objects you send across to the other side is fully serializable (i.e. no recursion, no native gui elements) ; if not it will fail unless you use some third party lib to serialize the recursive structure.
  4. Terminate() or Close() the webworker if you are no longer going to use it.  If you are planning on continuing to use it; then leave it running it is cheaper to leave it running (& not doing anything) than to terminate and restart.
  5. If you get an error message like this: Worker Error: Uncaught TypeError: Cannot read property 'prototype' of undefined this can mean it can't find the worker file that you wanted to load.  Using the tilde to say main app folder '~/path/to/worker' is the easiest way to fix it.  OR it can mean that the file that is required is doing something that is causing the worker to crash.
  6. If you see the error: Uncaught TypeError: global.moduleMerge is not a function The solution is to do a require('globals'); at the top of your worker file.

Once you understand these items, you are ready to rock and create cool background threads to do all your busy work so that your main thread never freezes again...

NativeScript Testing: Developer Days Video

I just noticed my video from my presentation was released.  This was the presentation that I did at #NativeScript Developer Day in Sept of 2016.   The subject was Testing your NativeScript app and dealt with both Unit Testing and End to End testing.

I saw a couple of "um" mistakes.    I "um" need to "um" work on "um" removing some "um"'s.  😉

Here are the questions at the end (since like an idiot, I also totally spaced about repeating them) are:
1. What about testing Angular2 NativeScript apps.
2. What about Code Coverage .

Slides Deck:

Demo "Carder" App I wrote and used, includes all the tests:

Detailed Blog posts about this subject covering the video:
Part 1 - Unit Testing
Part 2 - End to End Testing

NativeScript Testing: End to End


keyboardI got to give a talk on NativeScript testing to a great group of people at NativeScript Developer Days. 20160920_190247

Despite my silly technical problems at the beginning, we managed to get back on track and I was able to present all the critical information that was needed to get everyone up and running.  I did manage to miss my last slide; so I will make sure to have all that information at the end of each of these posts.

For those who are interested in doing testing and weren't there; or those who were in the talk, and just want to get a quick refresh, or if you just prefer the information written down; then this set of blog posts is for you.   I plan on doing a multi-part series on this as I want to cover what I did in my talk in the first two blog posts; but then expand the series to show Angular Native unit testing, how to unit test controls, and how to write unit tests for the NativeScript core.

You can view the #NSDevDay video here .  You can download my slide deck from the talk here.  And you can download the entire app that I wrote for my talk, including all the tests from here.

The posts currently planned in this series are:

Now as you might have guess even though you can do a lot of tests via unit testing, there are some limitations to unit testing.  You are typically only testing pieces of the whole.  So you really need to make sure the whole app works and the code you used to tie together all the pieces works.  And this is called End to End testing.

In my book, "Getting Started with NativeScript",  I discuss using Appium, for end to end testing.   Since the point where my book was published, one of the NativeScript engineers Hristov Deshev has actually created a really neat plugin.  It actually wraps up all the same steps that I came up for in my book.  Since it is a plugin, it is way easier to use, since it handles all the configuration and installation for you.  You just type tns install appium and it will install everything you need for end to end tests.   In this case all the tests for Appium will be stored in the root /e2e-tests folder since they don't actually need to be part of the Application itself.  Appium uses Mocha (which is the primary reason why I use mocha for my normal unit tests, I like consistency.).  It also uses Chia for the Asserts; so the tests are created the exact same way as I described in the unit testing post; with only a couple minor  changes.

So lets look at your /e2e-tests/carderAppium.js test that I provided in my sample testing application:

var nsAppium = require("nativescript-dev-appium");

The first thing you will notice is that I don't require any of the code from the app; the end to end testing does not run from inside your app; it is 100% external to your app.  So, you are at this point requiring the Appium setup and control driver library that Hristov wrote to wrap the configuration complexity.

describe("Carder app tests", function () {
    var driver;

    before(function () {
        driver = nsAppium.createDriver();

    after(function () {
        return driver
        .finally(function () {
            console.log("Driver quit successfully");

We still use the describe; but we have to actually setup the driver (that controls the device) in the before function.  And we tear it down (or close it down) in the after function.   Then we actually do all of our tests...
it("should find the card title", function () {
        return driver
            .text().should.become('Back of Card');

So in the first test, what we have to do is use the driver we created in the before function; pretty much everything uses the driver.  It is the communication channel to the device being tested.   Then the command we use is .elementByAccessibilityId('message').   This command will search the iOS or Android layout for any element in the UI that has the "message" accessibility id attribute set.   Now, in NativeScript this is actually set using the automationText property.  So if you look at my main-dynamic.xml or main-page.xml file; you will see:
<Label row="1" id="message" automationText="message" text="{{ text }}" class="message" tap="scrollOff" textWrap="true"/>

Then once the driver finds this element, it looks at the .text() value and that value should become "Back of Card".   When the app starts up; the first card chosen is the "Back of Card".  So if my app is actually running properly, this test will succeed.

Lets skip to the last test; as understanding it, will explain all the other tests in between. So lets figure out how it works.   Now first thing to understand is in the carder app; the numbers, letters and pips on the card are actually using a font.  So if you were to switch to Arial as the font, the actual underlying character is a "r" for the hearts pip.  So that is why I have "r" and "q" letter used in the tests...

// 'r' is the hearts pip
var heart = 'r';
// Setup our xpath
var xpath =  "//"+nsAppium.xpath("Label")+"[@text='"+heart+"']";

// Lets run our checks
return driver.elementByAccessibilityId("prior")

As you might have noticed we do another elementByAccessibilityId("prior") -- we are looking for the prior element which is a button in this case (xml is:
<Button automationText="prior" id="prior" text="Prior" tap="prior"/>).

Then once it exists we tap it twice.  As you can see you can keep stacking commands; so in this case we actually stacked tap twice.  This is important to know, because frequently you will want to do different tests to the same element; or multiple actions to the same element.  You can easily chain them.

Next up, we are using the elementsByXPath which searchs the UI for anything that matches the xpath and returns it.  And finally we check the number of elements found.

Appium allows you to set/get values of fields, emulate taps & gestures, act like typing in on a keyboard, or just act exactly like an end user would, and then you can verify the results.  This allows you to build complex tests for your UI that test the entire "user" exposed functionality.

Now lets go into some specific details on some of these commands that you need to be aware of in Appium and NativeScript testing.   The Appium web driver actually has a ton of different selectors; however since Appium was initially developed for the web, only a couple selectors in the Appium documentation actually work for your NativeScript mobile apps.   The two selectors you can use reliably is element(s)ByAccessibilityId and element(s)ByXpath.  "element" returns only the first element found.  "elements" (note the added 's') returns all elements found.    As discussed earlier, AccessibilityId uses the NativeScript automationText value to find item(s).

XPath actually allows you to drill down into the UI and find specific items that may have a specific hierarchy and/or certain parents.  For example; rather than search for all buttons, you can limit the search to buttons that are inside a GridLayout which is inside a StackLayout area.  However, the biggest downside with xpath is that it expects you to have the actual native android or native ios control type name.   For example; on Android the NativeScript Button class is actually using the android.widget.button.  The native class on iOS it is actually using an UIButton.   Now that makes XPath really, really hard to be cross platform test, doesn't it?     So to solve that issue; I have written a cool wrapper to help with this issue. It allows you to pass in your NativeScript class name and it will, depending on the platform you are testing against, will return the real underlying native component name.   So in this specific test case the xpath was "//" = any level of items, we aren't giving any specific parents (so find this anywhere in the layout).  Then my helper class nsAppium.xpath("Label") will give me the actual underlying UI name of a NativeScript Label component, and then finally "[@text='r']" means that element must have a "r" as the text field value.    In the case of the card it should find, the two pips on the edge of the card which should be a "r".  So this test would pass as long as the prior button worked to bring you to a King of Hearts card...

The next thing you need to be aware of in Appium is that you MUST return the driver results. You will see every one of my Appium tests does a return.   In all reality, the entire chain that we are doing is actually a promise chain.  So for the test to actually run and then pass/fail, the final result of the promise chain must be evaluated.  So ALWAYS return the promise chain, or your tests will say they passed without actually knowing for sure that it actually passed or failed.  This is CRITICALLY important you return the final promise!

The final gotcha in Appium is to know is at the top of the test file, the "this.timeout(100000);" is actually very important.  Appium can take a while to actually startup the DRIVER to communicate with the device/emulator.   And you really do not want the test to timeout (which = failure) before it actually starts running it.  So make sure at least for android, that this is a very large value...

A couple notes; Appium launching the driver can be extremely slow.  You have to wait a while before it actually appears to be doing anything.   Second; If you are using my NativeScript-LiveEdit plugin, the watcher now has a cool ability to be able to launch Appium when you hit the "a" button in the watcher window.

Now all of this can be automated and is highly recommended to be automated in something like local git hooks, or some other CI environment.   That way when you commit a change; Unless you have a beefy machine, I would recommend you set it to run on like every 3-5 commits (depending on how frequently you commit, it might be higher). Because Appium is fairly slow to get the whole test started.  At worst case I would recommend you run a Appium at least once a day, several hours before you go home...

If you need help setting up a automatic testing and/or CI environment or you would like some training, please contact me.



NativeScript Testing: Unit Testing

ns-road-signsI got to give a talk on NativeScript testing to a great group of people at NativeScript Developer Days.  20160920_190247Despite my silly technical problems at the beginning, we managed to get back on track and I was able to present all the critical information that was needed to get everyone up and running.  I did manage to miss my last slide; so I will make sure to have all that information at the end of this post.

For those who are interested in doing testing and weren't there; or those who were in the talk, and just want to get a quick refresh, or if you just prefer the information written down; then this set of blog posts is for you.   I plan on doing a multi-part series on this as I want to cover what I did in my talk in the first two blog posts; but then expand the series to show Angular Native unit testing, how to unit test controls, and how to write unit tests for the NativeScript core.

You can view the #NSDevDay video here .  You can download my slide deck from the talk here.  And you can download the entire app that I wrote for my talk, including all the tests from here.

The posts currently planned in this series are:

Unit Testing

So our first type of testing we will discuss is Unit testing.   Unit testing, for those of you that are un-aware of what it is -- it allows you to take a part of your code (typically a class or module) and you test it.  The best way is to treat it like a black box.  You don't care how it is implemented internally; you only care about the interface it exposes (i.e. inputs and the results).  By treating it as a black box; this allows you to re-implement/rewrite/refactor/fix it or do any other internal things to the class without the rest of your real or test code caring about the actual internal implementation.  Because your class is self contained it makes your code a lot more de-coupled and stand alone.  This typically means the code is better engineered and more maintainable.  In a nutshell, unit testing, is basically throwing as many different types of inputs and then verifying all the outputs and/or execution of your class is correct.

Now some people like to develop the tests before the code; this way they think of the scenarios that they need to handle; create all the tests (which of course at this point will all fail) and then implement the code.   Others build the code and build the tests along side the code, or build them after the code is complete.   There are pro's and con's for all sides; and that is really a whole different blog post.   In my opinion it is better to just make sure you do it; not the when of doing it.  One other recommendation is that when you get a bug report; you write a test for it. This way once you fix it; then in the future that specific bug will never happen again as your tests will always be checking for it.  Remember the idea is to test for everything you can think of, if a bug slipped through -- that means you failed to test everything and so by adding those "bug" tests, now hopefully you are actually testing everything the class can do...

The really cool thing is NativeScript actually has built in unit testing.   The neat thing about the built in unit testing, is it actually runs fully inside your NativeScript application.   This allows you to test anything that you have in your application including any added plugins, or custom code.   To install it, you just do tns test init.  This will ask you which testing framework to use and will install it.   I prefer using Mocha, and so the tests examples will all be mocha based; but again the framework you use is your choice.   One thing to note is that the assert functionality is actually provided by the Chia library in each of the testing frameworks supported by NativeScript.  If you really prefer a different assert library there are ways you can change it, but that is out side of the scope of this blog post.

For all your unit tests in NativeScript, they are all located in the /app/tests folder.  To then run all your cool tests  you will type tns test android or tns test ios.  TNS will then build your app and launch it in test mode.   Once each test completes; your console will tell you which tests passed/failed and then finally how many passed/failed like this.

NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 0 of 6 SUCCESS (0 secs / 0 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 1 of 6 SUCCESS (0 secs / 0.005 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 2 of 6 SUCCESS (0 secs / 0.007 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 3 of 6 SUCCESS (0 secs / 0.008 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 4 of 6 SUCCESS (0 secs / 0.009 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 5 of 6 SUCCESS (0 secs / 0.083 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 6 of 6 SUCCESS (0 secs / 0.085 secs)
NativeScript / 19 (4.4.4; Samsung Galaxy S5 - 4.4.4 - API 19): Executed 6 of 6 SUCCESS (0.217 secs / 0.089 secs

Lets get to the actual creating of tests in Mocha.  In my sample carder app; I provided a sample test file. So lets look at the unit test file I provided. The file is located /app/test/carderUnitTest.js.  The first thing you will see is that I include the class I plan on testing.

var cards = require('../cards.js');

Pretty hard to test it, without requiring it.   So in case it isn't obvious you still need to require the file(s) that contain any plugins/classes/module you need to test.

Then the next part of the code you will see is;

describe('Cards', function() {
    describe("current card", function() { 
        it ('should return ace of spades', function() {

The first line of this, we use the describe command to give the test a name, this allows you to know which test group passed or failed.  You can also nest describe's inside of describe's to allow you to have sub-groups of tests.   Finally you will see the it command, which is the actual test. You can have as many it's as you need in a group to test the full functionality.  So walking specifically through this test; we are saying the main test group is Cards (I name it after the class I'm testing); the following describe is I'm testing functionality I'm testing the current card function; and finally what my expectation of my test, which in this case is that it should return ace of spade card.

Then next we add our add my actual test code;

// Reset Card deck to known state
// The get "Current Card" function
var result = cards.getCurrentCard();
// My Expectations, that it should be
// a Ace of Spades on a reset card deck
assert.equal(result.suit, "Spade"); 
assert.equal(result.value, "Ace");

If either of the last two lines are false, then the test will fail and it will then mark this test as a failure in the log.

As you can see creating this test was fairly simple; Reset deck, grab the card and then verify it.  If you scroll down in the test file to the end of it; you will see the random cards test.  As you can see that test is a bit more complex.  Your tests can be as simple or complex as you need.  Typically the simpler your tests are the better, as then it is less likely that your test is actually the broken part of the code if it fails.

One other feature of Mocha is you can actually do ASYNC tests; so if your code is promise or callback based; you can also test it.  By doing this:

it ("Test promise", function(done) {
  .then(done).catch(function() { done(false); });

// or

it ("test callback", function(done) {
  someFunc(function(err, results) {
     if (results) done()
     else done(false);

Notice in the it function, it has a done parameter now.  The done() function is passed in for you to call when the async code has completed.  The mocha unit test detects if you tell it to have a done parameter and will switch that test to be fully async.

Note: If you are using my NativeScript-LiveEdit plugin, the watcher has had the ability to start these tests instantly on Android (Without having to use the slow `tns test android` command) for quite some time.  So anytime you change any of the /app/tests/ files; it will automatically launch the tests and you will see the results almost immediately.  However, I have recently added a couple new features to the watcher; you can hit inside the watcher window a "t" to start testing immediately; or the "m" to switch modes (i.e. default-auto-test, always test, and never test), and the "n" to force it to launch the app in normal mode.

Now all of this can be totally automated and it is highly recommended to be completely automated in something like local git hooks or some CI environment so that when you commit a change the unit tests are done.  The sooner your tests run the quicker you find any breaking code after you make any changes.  It is always very re-assuring when you have to fix a bug in your class and then  re-run your tests and everything passes...

Depending on your CI environment and how frequently you commit, you might consider having the heavier tests run once every three commits or based on a keyword put in the commit or in a issue tracking system.  Again, the idea is the more tests you can do and the more testing coverage you have the better off you are.

If you need help setting up a automatic testing and/or CI environment or you would like some training, please contact me.


NativeScript Developer Days

20160920_190247Well, we just finished the Conference yesterday!   Thanks for everyone coming out; I enjoyed meeting a ton of you.   And I hope everyone had a great conference.    For NativeScript being released as a Beta to the world 18 months ago; they had a large turn out.   In fact the Angular Native sessions had to be split into two rooms because so many people showed up.   Good problem to have!

Great job by Brian (and I'm sure others behind the scenes at Telerik & Progress) getting everything coordinated and setup.   It was an enjoyable conference with great speakers.

T.J. and Jen did a great job on the Angular 2 training session; I even learned some things in Angular Native; check out the in-depth tutorial on Nativescript.org, great stuff.

The Opening by Burke and Todd was very entertaining and love some of the history and vision you guys presented...    In 2014 NativeScript was started.  18 Months ago was when the beta was released, and the rate of adoption for NativeScript is through the roof.

I have to say, I'm still very very sad that Sebastian wouldn't let me steal his evil and "un-named" bot -- I would have provided a good home for it, and I could have helped with your goal of world domination...  So tell me Sebastian which room are you in again?     😉

I thought Alex Ziskind's talk was awesome, I don't use Office 365; but man your Plugin ROCKS!   If I get any clients that need that type of functionality; I know which plugin I will use.   Awesome job on both the plugin and the speech!   And to answer your question, Calendar would be my bet for next integration, everyone uses a calendar...

Nathan's Walkers ShoutOutPlay is awesome, I love how you blended using your ShoutOutPlay with your slides and talk; that was genius; and really made your talk shine!    Sharing! Sharing! Sharing!   😉

Congrats for MeWatt for winning the app contest -- the app & technology is very cool; but what stood out most to me is as I talked to the owner of the company (which he was an awesome guy) -- he mentioned that the app was built in 7 weeks from NO NativeScript knowledge to fully working on Android and iOS.   Holy smokes, 7 WEEKS to Awesome APP.   Talk about NativeScript being enabling!

And Raymond had a great talk to close out the day.  I so REMEMBER the magazines and typing in the many many lines of code; COMPUTE was the magazine I always waited for; I was on the c64...

The #MobileTea meetup after the #NSDevDay was cool.  It was people from the entire mobile community; React, Cordova, Native, etc...   The funniest thing that happened was two guys did a great job of presenting how to use PouchDB (on browser) and the native CouchBase library stuff on ios for doing local data and offline data and syncing of it.    However, the presentation on iOS he was showing the code for how to setup Couchbase and syncing and it was a lot of code.   (He did do a good job)...   So I did a quick search on our plugins site NativeScript.rocks for couchbase and found the plugin and the docs and it is 8 lines TOTAL of code to do the exact same thing in NativeScript and those 8 lines enable it on both Android and iOS...   NativeScript is just so COOOOOOL...  🙂

It was awesome to meet a several of the engineering team from Sophia -- we had some great discussions, and they now get to put a face to "that" guy that posts all those weird hard bugs that really mess up the schedules...  😀    The cool thing was we actually hashed out some great ideas for how to help enable several parts of the community to flourish more and how to help the community know what bugs we can easily work on ourselves from the TNS-Core.

It was also very cool to meet Rob, Brandon, and Clark from Progress/Telerik at the speakers dinner, all of them way behind the scenes at Telerik.   Rob, if you ever get any openings in your team -- it sounds like an awesome job, I love hacking on new technology....  🙂

And of course it was very awesome to meet Valio & Todd, Dan and Brian at Telerik, I chatted with each of them several times over the last 18 months, so it was great to finally meet and put faces to the name.

So if you picked up one word.  It was AWESOME...  Thanks again for everyone I got to talk to, and If I didn't put anything in here about you; my apologize; names and my memory sucks...

Oh and I plan on putting a blog post up later on my Presentation with the slide deck, link to the source & tests and all the key parts to help anyone who is interested in NativeScript Testing.     I understand the talks were all recorded; so I'll update the post to link to them when they are released!

NativeScript: Version 2.3.0 Released

ns-versionFor those hiding out in the forest; guess what was released by our cool park rangers at Telerik today!     Yes, you got it - v2.3.0 of NativeScript is now available!   Upgrade Instructions below.

As usual; if you run into any issues I will be putting any common issues at the bottom of this post as I and others run into them....

New or Fixed Features:

  • iOS XCode 8 support for iOS 10 support - * (I've heard this might not be fixed yet)
  • Navigation memory leak squashed
  • Android Text Hint Color supported
  • Buttons now support text-decoration and text-transformation properly
  • iOS d.ts generator works properly
  • Android Extend working properly again
  • Android now properly re-throwing exceptions (better error messages)
  • Android a couple crashing corner cases fixed
  • Observables fixed (was broken in some nested situations in 2.2.0)

A Lot of other smaller bug fixes and enhancements went into place; unfortunately the really big feature for 2.2.0 & 2.3.0 has slipped again -- threads.   It was a lot bigger than they expected; I've seen progress on both Android and iOS on this front; based on the activity it should be showing up in the masters channel soon, meaning we will be able to test and play with it soon.


First of all to upgrade is done is a couple steps:
> npm install -g nativescript
> npm install tns-core-modules@latest --save

For Android:
> tns platform remove android
> tns platform add android

For iOS
> tns platform remove ios
> tns platform add ios

Then you can type tns info and verify that everything says v2.3.x

Common Issues

Images and a parent that has Color set, causes the image to not show only the color that was set on iOS.   To fix you can do this a couple ways.  Remove the color on the parent.  Upgrade or disable the broken source (Line 133


in "node_modules/tns-core-modules/ui/image/image.ios.js, comment it out.