A couple of useful boolean values isDragging and isEnabled are to keep track of the current status of the object. 

IInputHandler inherits the OnInputDown and OnInputUp functions which commence and end the object dragging action. 
OnInputDown records the event as used (so that the dragging action doesn't get interrupted by another user action until completion). StartDragging is another function in MRTK which determines the source that initiated the dragging gesture (hand or controller). The MRTK version of StartDragging also looks for the camera position and the pivot position of the hand. I stripped this script down to simply record the object position at the start of dragging. 

UpdateDragging is another function which is called during Update. Similar to StartDragging, UpdateDragging continues to monitor and update the position of the object based on the hand's current position. The object's new position is calculated by using the Vector3.Slerp function which spherically interpolates between the current object's and hand's position to move the object to the new position
Vector3 draggedPosition = HostTransform.position + (handDistance * DistanceScale);
Vector3 newPosition = Vector3.Slerp(HostTransform.position, draggedPosition, PositionLerpSpeed);
SetHostPosition(newPosition)

Finally, a few functions to gracefully handle exiting the dragging motion, once the user releases the drag gesture. This invokes the OnInputUp inherited funciton, where I release the event (eventData.Use()) before calling a StopDragging function to fix the final position of the hologram

In the Hierarchy window, right click UI→Canvas. This creates an empty canvas to the scene. In order to make the canvas visible and interact-able with the Hololens, you have to do the following;
1. Change Render Mode to World Space. Unity will prompt you to update the canvas' WorldCamera to use the UIRaycastCamera. Click OK
2. Look and feel: This was really tricky and took multiple attempts (and research online). Generally you want to set the canvas X,Y,Z position to 0, 0, (some reasonable Z around 5. The canvas scaling should be anywhere between 0.01 and 0.1 (again this number is obtained by trial and error)
3. In the canvas Inspector,  Add Component→Layout→Vertical Layout Group. I like using this because it neatly organizes all the content I eventually place in the canvas. Once you are comfortable with canvas placement and object adjustment, you can disregard this step.

Great, we have a canvas! Now what?

Add Text
Let's add some text elements to this canvas. In the Hierarchy window, right click UI→Text. The text game object appears as a child under the canvas.

Text (script) is not editable (AFAIK). We will add a text mesh component (Add Component→Mesh→Mesh Filter). This field is editable, which will come in handy later on in this example. As before, we want a reasonably large font size and lower scale factor to get a crisp font rendering.  Since we have used a Vertical Layout Group for the canvas, the text position inside the canvas is frozen. Add the desired text. I also allow both horizontal and vertical overflow for the text.

Update (3/28/18): Text components are, in fact, editable. You need to include using UnityEngine.UI to editthe Text fields of objects in a canvas. This is done using GetComponentInChildren<Text>().text = "Insert string here"

Pro Tip: In this example, the upper left corner of the canvas is the (0,0) position and, just like a regular 2D graph, the lower right corner is (canvas width, -canvas height) coordinate. In our example, that will be (400,-400). You can visually see the canvas origin by the placement of the white cross-hairs on the canvas.

Add Button

Next step is to add a button to the canvas. In the Hierarchy window, right click UI→Button. The button object appears as a child under the canvas.
The button has some interaction controls and settings. These color options change the look and feel of the button depending on the situation. There is also a text component under the button. Type in "Click Here" in the Text (Script) area.

Add Sphere

The final object to add to the scene is a sphere with the red material created in the previous example. I added this at (1,1,5) with a scale of (0.3,0.3,0.3). The canvas is at (0,0,5) with a scale of (400,200).

The Scene
Now that the components have been added, let's work through the scene and build the scripts.
In this scene, we want to do the following:
1. If the user gazes at the button, change the color of the ball (IFocusable)
2. If the user air taps on the button, change the text with a running count of the number of taps (IInputClickHandler)

In the Scripts folder, create a new script called ButtonInteraction. We will create two public variables that hold the sphere and the text area. We will also create two private variables that hold the sphere's default color and the click count.
In brief, the OnFocusEnter and OnFocusExit scripts will change the default color to a random color and re-instantiate the default color respectively.
The OnInputClicked function will increase the click count and change the text mesh in the text area.
The code is provided below.

This is a sample visual of the game scene:

Assignment: Try adding a second button that resets the count. I'll leave this up to you to do but here are some hints:
1. Use the FindObjectOfType function to access the count number of the script associated with the first button
2. Use get and set methods to access private variables

Pro Tip: How can you find Primitive objects such as spheres and cubes in your scene? You can use tags. This is a clean solution if you want your UI objects to interact with objects in the scene such as players, enemies, objects, etc.

The first thing to do is create a new game object by right clicking in Hierarchy →Create Empty.  Rename this to PopupText. In the Inspector window for this object, click Add Component→Mesh→Text Mesh. This text mesh is where you can program the text to be displayed, the font size, style, etc.

Next, create a new folder under Assets called Prefab. This will be the place to store all user created objects (very useful for games) and things like text boxes, prompts, etc. Drag the PopupText object and place it in this folder. You have created your first prefab! Now you can delete this from the Hierarchy. A prefab can be instantiated and destroyed in any script. Learn more about Prefabs here. The prefab settings I used can be found at the end of this tutorial.

Instead of modifying the currently existing GazeAction script, let's create a new script called GazePopup in the Scripts folder. We will create a public variable textBoxPrefab of type GameObject to point to the prefab we previously created. We will also create a private variable textBox of type GameObject. This will hold the cloned instantiation of the prefab. This is necessary because we need to make this textbox disappear once the user moves her gaze away from the hologram. Unity does not allow the actual prefab asset to be destroyed (I learnt this the hard way!)

I wanted the text popup to appear whenever the user gazed at the hologram so I put the popup instantiation code in the OnFocusEnter function. I positioned it to appear an x-offset away from the object itself.

Once the user looks away from the hologram, you need to delete the text popup. This can be done by calling the Destroy method on the cloned instantiation textBox.

Pro Tip: Notice how the text popup appears conditionally based on the textPopup boolean value? This is because we don't want to create multiple copies of the prefab in our scene. Take out the if condition and see what happens

Pro Tip 2: To see a richer font quality, increase the size of the font in the prefab and scaling it down. Trial and error will get you the right answer

Configuring for airtap in Unity
This is one of the easier gestures to implement in Unity because we have already incorporated the InputManager. InputManager includes GesturesInput which contains scripts to detect hand gestures.

If you hit play in Unity, you will notice two hands that show up in the Game mode. This indicates that your application is already configured to accept tap, hold, and manipulation gestures. The left hand is selected by holding the left Shift key and the right hand by the Spacebar. Once a hand is selected, click using the left mouse button.

Creating a script to listen to gestures
Once again, in Assets→Scripts, create a new script and name it GestureAction. Open it in VS17.
This script imports from IInputClickHandler and requires a function OnInputClicked(InputClickedEventData eventData).

For this example, we will randomize the color of our sphere anytime the user performs an airtap gesture. Each game object has a Color component, accessed using GetComponent<Renderer>.material.color.
A new Color can be created on initialization by calling its constructor. A color is defined with 4 floats; components r,g, and b define the RGB space and alpha defines the transparency. We will randomize RGB and use 1.0 for alpha.
The complete code is shown below.

Test the script
Attach this script to the sphere in Unity. Hit play and test it. Does the color change?

Probably not. Don't panic! This makes complete sense. The Gaze functionality we developed forces the sphere's color (in my case, to blue). This overwrites any actions performed by the Gesture script. In the Inspector window for the sphere, disable Gaze Action and try it again. It should work this time round. The color of the sphere should randomize every time you click. Try it with both the "left" and "right" hand.

Fix the Gaze Script (optional)
We clearly don't want the Gaze and Gesture script to conflict. Instead of changing the color on gaze, we can change the metallic level of the object. Without going into too much detail, here's the code to do that in the GazeScript script.

Create a new Speech Manager
The first thing to do here is create a new empty object in the Hierarchy under Managers and name it SpeechManager.

Search for the SpeechInputSource script in Assets and drag it into this new object. For this example, we are going to change the size of the sphere by either a) Increasing size b) Decreasing size or c) Going back to default size.

In the Inspector window of the SpeechManager object, expand the Keywords menu under Speech Input Source. Let's add some keywords that our application can recognize. Click the + button and add 3 keywords: Increase size, Decrease size, Default size. I also added some options under Key Shortcut to allow us to test the speech recognition script that we will develop through Unity

Create a script to recognize keywords
This step involves creating a new C# script to perform certain tasks on the sphere once a voice command from the list created above is recognized.
Under Assets→Scripts, create a new C# script and name it SpeechAction. Open it in VS 2017. The SpeechInputSource script inherits from ISpeechHandler. Similar to what we did for Gaze, our new script will also inherit from ISpeechHandler and, in the header, we will add the command using HoloToolkit.Unity.InputModule to import this functionality. 
The function that is inherited is OnSpeechKeywordRecognized(SpeechKeywordRecognizedEventData eventData

Whenever a voice command is issued while gazing at the holographic object, this function is called. Within this function, we can parse the input and, based on what the user has said, we can call the appropriate sizing function on the object.

The code snippet to parse the input is shown in the screenshot below, but first let's discuss how to change the size of the object. The object has a transform component that has a Vector3 localScale parameter. This represents the size of the object in x, y, and z.

To change the size of the object, we have to simply manipulate this parameter. We can create two SerializeFields that hold scaling factors for increasing and decreasing the object. These values can be manipulated from the sphere's inspector window once this script is attached to it.

Pro Tip: You generally shouldn't need to use SerializeFields. For public variables, Unity automatically serializes them in the object's Inspector window. Using SerializeFields for private variables will also show them in the Inspector window.

In order to remember the default object size, we can save this parameter to a private variable in the void Start() function, which is called at the beginning only, during object creation.

The complete script is shown below. Remember to drag it to the sphere to attach it.

Testing the Script
Hit play in Unity to test the script. If you do not have a microphone configured to receive input in Unity (I don't) you can use the key shortcuts instead. In my project, 0 = Increase size, 1 = Decrease size, and 2 = Default size.

This simple example hopefully shows how voice commands can be used to interact with your holograms. Try something else like changing the color of the object instead, by assigning a new color to gameObject.GetComponent<Renderer>().material.color.

Getting the project ready in Unity

Under the HoloToolkit menu, click Configure→Apply Hololens Project Settings. A popup menu will display a list of selectable settings. Select all of them and hit Apply.
Unity will prompt you to reload your project in order for the changes to take effect. This is a one-time thing for any new project.

Once Unity has restarted, click File→Build Settings. Click on Add Open Scenes to add your main scene to the build menu. Make sure that the platform selected is Universal Windows Platform. The settings in the image below are what you need:

Before we click Build, click on Player Settings.
In the Inspector menu, click Publishing Settings→Capabilities. Make sure Microphone, SpatialPerception, and Bluetooth (in case you are using the Clicker accessory) are selected.
In the Inspector menu, click Other Settings. Make sure Virtual Reality Supported is selected and Windows Holographic shows up under Virtual Reality SDKs.

Now we are ready to click Build in the Build Settings window. A File Explorer window will popup, prompting you to save the build location. The consensus here seems to be to create a new folder called App and selecting this folder for your build.

Connecting to your Hololens
The first thing to do when turning on and logging into your Hololens is to enable developers mode. Go to Settings→Update and Security→For developers. Turn developer mode on. This will prompt you to enter a username and password to access your device remotely.

Under the Paired devices menu, click on Pair. This will open a prompt with a PIN that is required when first pairing with the device.

On the same page, under Device Portal, enable remote management of the device.

We will be deploying our Hololens app via WiFi, so go ahead and get the IP address of your device from Settings→Network and Internet→Wi-Fi. Click on Advanced Options and record your IPv4 address. Mine is 192.168.0.105.

Make sure that your Hololens is able to talk to your PC by opening a new browser window on your PC and navigating to https://192.168.0.105 (replace this with the IPv4 address you recorded above). If all goes well, you should see this page:

Deploying the application

The device has been paired to your PC and the project is ready for deployment. In a File Explorer menu, navigate to the App folder you created for your project and double click on the .sln file. This will open Visual Studio 2017.

Under the menu, you will see the following deployment options:

Make sure you have selected x86 as the Solutions Platform and Remote Machine as the location of the machine you wish to deploy your app. Selecting Remote Machine will open another prompt asking you to find the Hololens device. You can either manually enter the IP address under Manual Configuration or let VS17 auto detect the device.

Hit the Play button for Remote Machine.
Deployment can take a while, depending on the size of your application. Sometimes, VS17 will prompt you to enter a PIN to establish connection with the device. Enter the PIN you saved when clicking on Pair, under settings in the Hololens.

Once the app has been successfully deployed, VS17 will display Ready at the bottom of the screen. Enjoy!

Create a Script

The HoloToolkit contains scripts and interfaces that allow us to use the Gaze feature of the Hololens. The interface that we will be using is the IFocusable interface, located in HoloToolkit→Input→Scripts→InputHandlers

Pro Tip: Find any script by searching for it in the search bar in the Projects window. A list of scripts included in the Mixed Reality Toolkit can be found here.

Let's open this up by double clicking it. It should launch Visual Studio 2017.
The IFocusable script contains two empty functions, OnFocusEnter and OnFocusExit. The names of these functions give it away; one will be called when we gaze on the object, and the other will be called when the gaze is removed from the object. We will leverage this script in a new script that we will create for customized gaze actions.

Back in Unity, under Assets, create a new folder called Scripts. This is the folder where we will place all our custom scripts. In this folder, create a C# script called GazeAction. Open it in Visual Studio. The empty script should look something like this:

In order to use the functions from IFocusable, and for the InputManager to understand how to tie the gaze action to these functions, we need to inherit it in our custom script. We also need to import an additional interface - using HoloToolkit.Unity.InputModule - to our script.

Gazing at the Object

For this project, when we gaze at the sphere in our game, we want to change its color from Red to Blue. Create a new function public void OnFocusEnter(). In this function, we will first save the current color of the sphere. To access the color of the sphere, we need to get its Renderer component, as follows:
var temp = this.gameObject.GetComponent<Renderer>( );
Here, gameObject refers to the specific game object that this script is attached to. Refer here for more information on GameObject class in Unity.

Now, the current object color needs to be saved. Let's create a private variable in this script called originalColor. The variable is made private so that no outside function or object has access to it. The color can now be saved:
originalColor = temp.material.color;

The last thing left to do is to assign the object's color to another color. We can create a public Color variable called gazeColor and initialize it to a color of choice. In my case, I assigned it to Color.blue. The object's color when gazed on can be changed as follows:
temp.material.color = gazeColor;

Gaze removed from Object

When the gaze is removed from the object, we want to assign it back to its original color. The code is similar to the above case:
var temp = this.gameObject.GetComponent<Renderer>( );
temp.material.color = originalColor;

The completed script looks like this:

Assign Script actions to Game Object

Now that the script is done and saved, we have to assign it to the sphere in our project. In Unity, drag the script onto the sphere in the Hierarchy. If you now navigate to the Inspector menu, you will see the custom script appear. There is also a field for Gaze Color since we had made that public. If you do not like the color blue, you can change it to anything else from the Inspector panel. You do not need to edit your script to change the value of a public variable.

Try your script out by entering the game mode (by clicking Play) and moving the cursor around with the arrow keys. If the cursor is focused on the object, it should change color (turn blue in my case). If the cursor is removed from the object, it should go back to its original color (red in my case).

That's it! You developed your first Gaze action!

Extra Credit: Try changing the color of the sphere to a random color whenever the user gazes at it. Hint here

Create a sphere

In Hierarchy, under the Create menu, create a 3D Object → Sphere. You should see a sphere show up in your Scene.
The sphere appears right on top of the camera. If you switch to the Game view, you won't be able to see the sphere. We can fix that by moving the sphere out in the z direction in one of two ways:
1. Select the Sphere under the Hierarchy. Navigate to the Inspector panel and change the Z position number
2. In the Scene, drag the blue arrow (the Z direction arrow) away from the camera.

The sphere should now be visible in the Game view. It may be larger than the field of view of the camera. Fix that by either moving the sphere even further out in the Z direction or by adjusting the scale values in the Inspector panel.
This is what my Inspector panel looked like at the end.

Woohoo! We have a sphere. It's quite unattractive though. We can edit the visual attributes of this object by changing its material.

Changing the Material

The Material class in Unity allows you to control the visual appearances of game objects. We can edit attributes of this class to change the color, shade, and texture of objects.

In the Assets folder under Projects, create a new folder and name it Materials. In this folder, Create → Materials. Rename it to something that will better describe the look and feel of how you imagine the sphere. I named mine RedMaterial.

With this new material selected, under the Inspector tab, use the eye-dropper tool located next to Albedo to pick a color from the color panel that pops up. Drag this material onto the sphere in the Hierarchy panel.

At this point, your sphere should look like something similar to the image below. You can change the X and Y position to offset it further from the camera. Save the scene!