Posts Tagged ‘ Example Code ’

Beep! Beep!

So I wrote a post about creating basic beeping sounds in C# a few months ago:
https://inphamousdevelopment.wordpress.com/2012/05/07/console-beep-for-64-bit-windows/

Well, someone asked me if I could make the source code available. Well, because I’m a nice guy, I’ve cleaned up the project and uploaded it here:

http://phamous-apps.com/wordpress/MusicBeeperPA.zip

You will need Visual Studio 2010 or newer to run the project as-is. I have not tested it in Mono, and I do not guarantee that it will work in Mono. The code is offered AS-IS WITH NO SUPPORT.

If you find the project useful, please make a video response to the YouTube video with your creation.

Sending callbacks from C# to C++

Some days you just have to work with old methods to get the job done. I am working on a project that needs to be in native C++ for legacy reasons, but would prefer to bring it to the modern era of programming by using C#. I wanted a way to get data from the native classes to the managed classes so the entire program could be extended easier in the future and made more simple for someone to use (the original program was very linear and very tightly integrated that the user was required to be a programmer to use it). Using Microsoft’s Common Language Infrastructure (CLI) as a bridge between native C++ and managed C#, it is possible to make the two play together nicely. I’m going to assume that you have a basic knowledge of Microsoft Visual Studio 2008 and basic C#/C++/CLR coding skills.

If you want to follow along, the complete code for the demo program is available at:

http://phamous-apps.com/wordpress/NativeCallbackDemo.zip

I first create a new C++/CLR Class Library and a new C# Windows Form application in Visual Studio:

My solution looks like the following image. CEventTest is the CLI bridge between native and managed classes while NativeClass is a class written in pure C++. I keep all the code in the header file so there is nothing in the CPP file except for a #include for the associated header file so the compiler will compile the program.

The C# project (EventTest) is just a windows form with a multi-line textbox and some buttons like the following image.

In NativeClass.h, I have the following code:

#pragma once

#include
using namespace std;

typedef void (__stdcall *CallbackType)(unsigned char*, int);

class NativeClass
{
public:

    NativeClass(void);
    ~NativeClass(void);

    void CreateByteArray(CallbackType callback)
    {
        int size = 64;
        int byteSize = size * sizeof(float);

        unsigned char* byteArray = new unsigned char[byteSize];
        float* myFloatArray = new float[size];

        for(int i=0; i<size; i++)
        {
            myFloatArray[i] = (float)i * 2;
        }

        memcpy(byteArray, myFloatArray, byteSize);

        callback(byteArray, byteSize);
    }
};

Ok, this seems like very advanced code, but keep calm and I’ll explain what’s going on. The line:

typedef void (__stdcall *CallbackType)(unsigned char*, int);

declares the callback function prototype. CallbackType is a type that I made up. You can call it FooBarType if you want. The next part is the parameter list of the function that is going to be passed. The function I’m sending will have a byte array (unsigned char pointer) and an integer (to define the size of the array). The rest is standard boilerplate code for a function pointer. Just accept that it is magic and change the parts that I mentioned.

The rest of the file is a standard C++ class. The function CreateByteArray takes in the function pointer, so “callback” contains the pointer to the function. We can use “callback” like any other function now. The rest of the code of this function creates a byte array and fills the array with sequential float values. At the end of the function I use “callback” like a normal function. So, that’s one step and the native code is done for now.

Let’s turn to the CEventTest class now. CEventTest will bridge the native code with the managed code. The code is as follows (the comments will explain the code):

// CEventTest.h

#pragma once

#include
using namespace std;

#include "NativeClass.h"

namespace CEventTest {

	// must be outside of class so other classes can use them
	public delegate void NumberSender(int x);

	// delegate used for native C++ callback function
	public delegate void NativeDelegate(unsigned char* buffer, int bufferSize);

	public ref class Processor
	{
	private:
        // native C++ class to use. it must be a pointer.
        static NativeClass* nativeC;

        // must be declared outside of method or else garbage collector will delete!
        static NativeDelegate^ callback;

	public:

		/*
		events must be static in order to be accessed by thread
		and is public so other class can register the event handler
		*/
		static event NumberSender^ SendNumber;

		/*
		This function starts the C++ native class and passes our managed method to it as a callback funtion.
		*/
		static void StartNative()
		{
			using System::IntPtr;
			using System::Runtime::InteropServices::Marshal;

			// get a pointer to the delegate
			IntPtr cbPtr = Marshal::GetFunctionPointerForDelegate(callback);

			// call the native C++ function with our delegate pointer
			nativeC->CreateByteArray(static_cast(cbPtr.ToPointer()));
		}

		// constructor
		Processor()
		{
			nativeC = new NativeClass();

			// cast our managed method to a delegate
			callback = gcnew NativeDelegate(&Processor::NativeByteReceiver);
		}

		// destructor
		~Processor()
		{
			delete nativeC;
		}

		/*
		Our managed method which is to be used as native C++ callback function
		*/

		static void NativeByteReceiver(unsigned char* byteArray, int byteSize)
		{
			int size = byteSize / sizeof(float);

			float* myFloatArray = new float[size];

			memcpy(myFloatArray, byteArray, byteSize);

			for(int i=0; i<size; i++)
			{
				// signal an event
				SendNumber((int)myFloatArray[i]);
			}
		}

		void RunNativeDemo()
		{
			StartNative();
		}
   };
}

Delegates are the equivalent of callback functions in CLI. They must be declared outside of the class like the callback function declaration in C++. I’ve declared two delegates here:

public delegate void NumberSender(int x);
public delegate void NativeDelegate(unsigned char* buffer, int bufferSize);

The first delegate “NumberSender” is used to send an integer value to managed code (ie- the C# class). The other delegate “NativeDelegate” is used to magically take the managed C++ function and get a function pointer for the native C++ class. Remember the managed function and the delegate must have the same argument list (an unsigned char pointer and an integer).

In the class, the native C++ code must be in an object so a pointer can be used. Just accept that it has to be a pointer in order for it to work so that is why it is a static pointer:

// native C++ class to use. it must be a native pointer.
static NativeClass* nativeC;

I also have a public event so that the event can be registered with managed classes:

// managed CLI pointer for the event
static event NumberSender^ SendNumber;

The function for starting the native code has to be static. We need to use the IntPtr type and the Marshal class to get the pointer. A new NativeDelegate is created and is told the function in this class to use. Pass the memory address to the delegate constructor. Then a memory pointer is derived via marshalling. Then we call the function in the native class like normal, but we need to cast the delegate pointer to the callback function type that was declared in native class. Just change the following code to suit your needs.

/*
This function starts the C++ native class and passes our managed
method to it as a callback funtion.
*/

static void StartNative()
{
    using System::IntPtr;
    using System::Runtime::InteropServices::Marshal;

    // cast our managed method to a delegate
    NativeDelegate^ callback = gcnew NativeDelegate(&Processor::NativeByteReceiver);

    // get a pointer to the delegate
    IntPtr cbPtr = Marshal::GetFunctionPointerForDelegate(callback);

    // call the native C++ function with our delegate pointer
    nativeC->CreateByteArray(static_cast(cbPtr.ToPointer()));
}

When the function is called in the native code, the order of events shift back to the CLR class:

/*
Our managed method which is to be used as native C++ callback function
*/

static void NativeByteReceiver(unsigned char* byteArray, int byteSize)
{
    int size = byteSize / sizeof(float);

    float* myFloatArray = new float[size];

    memcpy(myFloatArray, byteArray, byteSize);

    for(int i=0; i<size; i++)
    {
        // signal an event
        SendNumber((int)myFloatArray[i]);
     }
}

It does the reverse of the native class function where it takes the byte array and puts the data into a float array. Each value in the float array is then sent to the C# code via the SendNumber event.

The last function in the class (“RunNativeDemo”) just starts the entire process.

Go to the EventTest project in the Solution Explorer, right click on the project name, and click “Add Reference”. Find the project CEventTest and add the reference. Now the CLR library can be used by the C# windows form project!

In the C# designer view, double-click on the “Native Demo” button and it will generate the method stub. Create the object for the CLR class library (I name the class “Processor” and the object “countThread”). Inside the button’s method stub, I just called the function that runs the native code via CLR.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

// remember to include the reference to the CLR class library
using CEventTest;

namespace EventTest
{
	public partial class Form1 : Form
	{
		// declare the CLR object
		private Processor countThread;

		public Form1()
		{
			InitializeComponent();

			// initialize the CLR object
			countThread = new Processor();

			// link the event for the number sending to a function in this class
			Processor.SendNumber += new NumberSender(Processor_SendNumber);
		}

		/// <summary>
		/// Given an integer, display the number in the textbox
		/// </summary>
		///The integer value sent from the caller
		void Processor_SendNumber(int x)
		{
			// Invoking is required for accessing GUI components
			if (this.InvokeRequired)
			{
				Invoke(new NumberSender(Processor_SendNumber), new object[] { x });
			}
			else
			{
				// Create a string with the number to display in the textbox
				textBox1.AppendText(string.Format("Received Value: {0}\r\n", x));
			}
		}

		/// <summary>
		/// Starts the process to run native code
		/// </summary>
		private void uxNative_Click(object sender, EventArgs e)
		{
			countThread.RunNativeDemo();
		}
	}
}

The callback function in the form requires invoking the delegate. The subject matter is somewhat advanced to explain here so if you want to know more then read up on MSDN and Google. We’ll just accept it as magic here. As long as you have the if-else statement like the above code, swap out the delegate for your own delegate, put your argument list in the object array, and put the GUI-related code in the else block, then you are fine.

Compile the project and run. If everything is working correctly, when the “Native Demo” button is pressed, it should show a list of numbers in the textbox.

There we go! It’s magic! I’m sorry if I skipped a lot of conceptual details because I know I did but I just wanted to throw some code out there for those who want to see the concept in action. It seems there are a lot of write-ups out on the web that explain the theory and have a very basic example, but nothing to show a practical use of the concept.

I also want to note that even though my example uses a byte array, you can use any type you want for the callbacks. Floats, integers, doubles, arrays, etc. I just chose to use a byte array because that is what my project required. I could have just sent the original float array as-is if I wanted to. All I would have to do is change the type to float* instead of unsigned char* and remove the mempy step.

Also it may seem a bit much too just return a byte array from native C++ to C# in this way, but the original code in my project had the callback in a C++ thread (to separate it from the C# GUI thread), which would have complicated the example. I did not want to confuse you so the threading code was removed.

Hopefully this tutorial helped someone and didn’t bore anyone to sleep. For further reading, these links were the ones I used to piece this project together:

http://stackoverflow.com/questions/6507705/callbacks-from-c-back-to-c-sharp

http://stackoverflow.com/questions/2298242/callback-functions-in-c

http://forums.asp.net/t/571841.aspx

Enumeration and arrays

Recently, I discovered the usefulness of the enum type in C++. I can’t believe how long I’ve gone without using an enum because I didn’t know why I should use it over a #define. The two main reasons to use enums over #define is 1) sequential self-numbering and 2) enums allow the value to be visible to the debugger. This post is about the first reason.

Let’s say we want a list of variables, and the variables need to be assigned a unique number for processing, but we don’t care what number is assigned to it. Enumeration to the rescue! Define an enum with a list of variables and it will assign each variable an integer value starting from zero. For example:

enum
{
    alpha,
    beta,
    delta,
    gamma
};

// The values stored in the enum variables are:
// alpha == 0
// beta == 1
// delta == 2
// gamma == 3

Now you can add another variable to the the list in any position (because remember we don’t care what number is assigned to it, it just has to be a unique number) and you won’t have to renumber the other values. It just does it automatically!

enum
{
    alpha,
    beta,
    omega, //<---------
    delta,
    gamma
};

// The values stored in the enum variables are:
// alpha == 0
// beta == 1
// omega == 2
// delta == 3
// gamma == 4

You’re probably thinking: “Great, it self-numbers. What’s the point?” Well the point is that you can use this as array indices and declarations. Assume you have some boolean option settings for your program with the following options: isFullScreen, isWidescreen, isMoving.

Let’s start out making a new file called “options.h” with the following code:

namespace options
{
    enum
    {
        isFullScreen,
        isWidescreen,
        isMoving,
        size
    };
}

I put the enum inside a namespace so that I can use the enum in multiple places without creating an instance of an object. The namespace also allows Visual Studio to list all the enum variables in the autocomplete dialog when using the scope operator ("::"). All I need to do is add #include "options.h" to the top of the header files where I want to use this enum. The last variable size is always going to be the size of the array. Now, remember an enum variable is a const integer value which is why we can use it as an array index value. To use this enum in a class I would use the following code snippet:

// include the namespace file
#include "options.h"

// declares the array, but does not initialize the elements
bool myOptions[options::size];

// then I can initialize the values like so:
myOptions[options::isFullScreen] = false;
myOptions[options::isWidescreen] = false;
myOptions[options::isMoving] = false;

...

// usage example
if(myOptions[options::isFullScreen])
{
    // do something
}

That’s fine and dandy, but if we add another option, we would have to add another line to set that option to false on initialization. We’re lazy and are willing to write more code now to prevent having to write more code in the future so let’s add a reset function to the options namespace.

namespace options
{
    enum
    {
        isFullScreen,
        isWidescreen,
        isMoving,
        size
    };

    static void Reset(bool myArray[options::size], bool value);
}

// the following lines of code are in the same file as the namespace
/**
@brief Resets all the options to a specific value
@param myArray  The array of options using the namespace's enum
@param value    The value to assign to all the options
*/
void options::Reset(bool myArray[options::size], bool value)
{
    for(int i=0; i<options::size; i++)
    {
        myArray[i] = value;
    }
}

I put a value as a parameter because I want the flexibility to set all the options to true or false. The static keyword allows us to use the function without declaring an object so we just reference the function like so in the class:

// declares the array, but does not initialize the elements
bool myOptions[options::size];

// resets all the options
options::Reset(myOptions, false);

...

// usage example
if(myOptions[options::isFullScreen])
{
    // do something
}

Now let’s add another option to the enum to detect if a file is loaded:

namespace options
{
    enum
    {
        isLoaded, //<-----------
        isFullScreen,
        isWidescreen,
        isMoving,
        size
    };

    static void Reset(bool myArray[options::size], bool value);
}

The beauty of this is I can add this function without having to renumber or edit the existing code! I just add the new option where I need to use it.

// still works correctly
if(myOptions[options::isFullScreen])
{
    // do something
}

// do this for the new option
if(myOptions[options::isLoaded])
{
    // do something
}

This is not the only example for using enums with arrays. There are so many possibilities such as having an array of strings and looping through it to read the values. Learning how to use enums for arrays changed my life. It has made me more productive and made maintenance so much easier. It’s such an elegant, cheap, and easy way to improve the code tenfold.

Dividing an array

Even if you don’t care about the practical applications of it in modern programming, it offers a look back when programming was more of a pain in the ass because shit needed to be set up properly as well as having a good algorithm. Actually it is still relevant in deeper technical programming that is closer to the hardware level. Probably not so much for app developers.

So let’s say you have an array using 16-bit integers. So you would have something like this:

unsigned short *myArray = new unsigned short[1024];

So you fill it up with data and all is good right? Well now your next requirement is that you want to divide each element into two parts, the lower byte and upper byte because the upper byte indicates the flashing pattern of the red LED and the lower byte indicates the flashing pattern of the green LED. Well FML, right? No!

We make a new byte pointer (a char in this case) and make it point to the typecasted main array:

unsigned char* birchPointer;
birchPointer = (unsigned char*) myArray;

Now because a char is a byte in size, when you advance the index it will point to the next 8-bit position. So let’s say myArray contains the following information:

myArray[0] = 0xBEEF;
myArray[1] = 0xCAFE;
myArray[2] = 0xBABE;

Now if you use the char pointer to access myArray, you’ll get the following information (providing your system is big endian):

birchPointer[0] = 0xBE;
birchPointer[1] = 0xEF;
birchPointer[2] = 0xCA;
birchPointer[3] = 0xFE;
birchPointer[4] = 0xBA;
birchPointer[5] = 0xBE;

If you’re using a machine that’s little endian (which most PCs are), then the byte values will be swapped like so (due to little endian storing the lower byte first in the memory sequence):

birchPointer[0] = 0xEF;
birchPointer[1] = 0xBE;
birchPointer[2] = 0xFE;
birchPointer[3] = 0xCA;
birchPointer[4] = 0xBE;
birchPointer[5] = 0xBA;

So there you have it: splitting a 16-bit array into an 8-bit array and learning something about how endians affect it.

Read more:
Size of C++ Datatypes
Big endian vs. little endian

Using a ViewSwitcher in your Android xml layouts

ViewSwitcher is an interesting thing, and you may find use for it in your project for various uses.  Ive implemented it for you in a thread type fashion, where it could act as a loading screen.  Don’t think this is all it is useable for however.  I’ve attached the project below.

The basic premise is you put the <ViewSwitcher> tag around 2 different layouts in your xml file, and then declare a variable in your main activity, a ViewSwitcher.  Then, to switch  between views, just call switcher.showNext() and switcher.showPrevious().

private ViewSwitcher switcher;
private static final int REFRESH_SCREEN = 1;

/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
	super.onCreate(savedInstanceState);
	setContentView(R.layout.main);

	switcher = (ViewSwitcher) findViewById(R.id.profileSwitcher);
	startScan();
}
... Finish the rest of your program

And this is how you will switch between the views

switcher.showNext();  // Switches to the next view
switcher.showPrevious();  // Switches to the previous view

Showing the ViewSwitcher tag in action!

<?xml version="1.0" encoding="utf-8"?>
<ViewSwitcher xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/profileSwitcher"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent">
<RelativeLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">
    <ProgressBar
        android:id="@+id/progressbar"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerVertical="true" />
    <TextView
        android:text="Loading…"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:layout_toRightOf="@+id/progressbar"
        android:gravity="center"/>
</RelativeLayout>

<RelativeLayout
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:gravity="center_horizontal" >
    <TextView
        android:text="Finished!"
        android:layout_height="wrap_content"
        android:layout_width="wrap_content"
        android:layout_centerVertical="true" />
</RelativeLayout>

</ViewSwitcher>

Heres some screenshots, and the source as promised, enjoy!

http://www.inphamous.com/code/examples/ViewSwitcherExample.zip

 

-Kevin Grant

Changing the position of the toast in Android

As with most example on the internet, this is made way more complicated than it needs to be, everywhere.
Normal Toast

Toast.makeText(getBaseContext(), "This is a long toast", Toast.LENGTH_LONG).show();

Custom Position (or custom anything)

Toast customToast = new Toast(getBaseContext());
customToast = Toast.makeText(getBaseContext(), "IM MOVED!!", Toast.LENGTH_SHORT);
customToast.setGravity(Gravity.TOP|Gravity.LEFT, 0, 0);
customToast.show();

I’ve attached the sample project, but really its quite simple.

http://www.inphamous.com/code/examples/CustomPositionToast.zip