The first step is to download our library from http://getlittleapps.com/little-software-stats/libraries/csharp-latest.zip

2) Include The Library

Using a Windows Forms Project that was created, add the “Library” folder to your solution. Next, you’ll want to open up Config.cs and modify it so it works with your Little Software Stats:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LittleSoftwareStats
{
    public static class Config
    {
        public static bool Enabled { get; set; }

        internal static string ApiUrl
        {
            get
            {
                UriBuilder uri = new UriBuilder((Config.ApiSecure) ? ("https") : ("http"), Config.ApiHost, Config.ApiPort, Config.ApiPath);

                return uri.ToString();
            }
        }
        internal static string AppId { get; set; }
        internal static string AppVer { get; set; }

        // Nothing above this line should be changed!
        internal const string ApiHost = "stats.yourwebsitehere.com"; // Set this to your Little Software Stats URL
        internal const int ApiPort = 80; // The port for Little Software Stats (usually port 80 or port 443 for HTTPS)
        internal const bool ApiSecure = false; // Set to true if using HTTPS
        internal const string ApiPath = "api."+ApiFormat; // You should only have to change this if your web server doesn't support URL rewriting

        internal const string ApiFormat = "json"; // The API Format (JSON or XML)
        internal const string ApiUserAgent = "LittleSoftwareStatsNET"; // The user agent to send to the API
        internal const int ApiTimeout = 25000; // Time to wait for the API to respond 
    }
}

3) Integrate with your software

Now you’ll want to integerate Little Software Stats by calling it using your software code. This example is from the Little Software Stats C# library which shows how to use the library

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;

namespace LittleSoftwareStatsNET
{
    public partial class Form1 : Form
    {
        LittleSoftwareStats.Watcher _watcher = new LittleSoftwareStats.Watcher();

        public Form1()
        {
            InitializeComponent();

            // Must be set to true in order for data to be sent
            LittleSoftwareStats.Config.Enabled = true;
            // Tells library to start collecting data
            this.m_watcher.Start("YOURAPPID", "YOURAPPVERSION");
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Make sure libary is still started
            if (this._watcher.Started)
                // If it is then stop it and send data before application exits
                this._watcher.Stop();
        }
    }

There is also an example Windows Forms C# project already made which is included with the library. You can use that to test and make sure that your Little Software Stats is receiving data properly.

LittleSoftwareStats.Watcher Functions

There are other functions that can be utilized to collect data using LittleSoftwareStats.Watcher which are described below:

// Starts tracking software
// Example: this._watcher.Start("26ad4eb8f804200f1e23b27c1873d703", "1.0");
void Start(string ApplicationID, string ApplicationVersion);

// Stops tracking software and sends data to API
// Example: this._watcher.Stop();
void Stop();

// Track an event
// Example: this._watcher.Event("Events", "Scan");
void Event(string EventCategory, string EventName);

// Track an event value
// Example: this._watcher.EventValue("Settings", "Theme", "Blue");
void EventValue(string EventCategory, string EventName, string EventValue);

// Track an event period
// Example: this._watcher.EventPeriod("Scans", "Clean", 360, true);
void EventPeriod(string EventCategory, string EventName, int EventDurationInSeconds, bool EventCompleted);

// Track a log message
// Example: this._watcher.Log("Hello World!");
void Log(string LogMessage);

// Track software license
// License parameter ("l") can be either (Free, Trial, Registered, Demo, or Cracked
// Example: this._watcher.License(LittleSoftwareStats.Watcher.Licenses.Free);
void License(Licenses l);

// Track custom data
// Example: this._watcher.CustomData("GFX Card Brand", "NVIDIA");
void CustomData(string Name, string Value);

// Track an exception
// Example: this._watcher.Exception(new DivideByZeroException());
void Exception(Exception ex);
void Exception(string ExceptionMsg, string StackTrace, string ExceptionSrc, string TargetSite);

// Track an installation
// Example: this._watcher.Install();
void Install();
// Track an uninstallation
// Example: this._watcher.Uninstall();
void Uninstall();

Development Version

You can get the latest developer version of this library from the Bazaar VCS. This version is not recommended, but it does contain new features. You will need the Bazaar VCS to download the developer version.

You can get a copy of the branch using the command:

$ bzr branch lp:~lss-team/lilsoftstats/net-library

You can also browse the source code here:
https://code.launchpad.net/~lss-team/lilsoftstats/net-library

The first step is to download our library from http://getlittleapps.com/little-software-stats/libraries/cppdll-latest.zip

2) Include The Library

Using a Windows C++ project that you created, add the “LittleSoftwareStatsDLL.dll”  (located in the DLL folder) to the folder where the result of the compiled code is located.

3) Integrate with your software

Next, you’ll want to call the DLL from your code to use it with your Little Software Stats. The following code is from Example.cpp which is included in the library:

/*
 * Little Software Stats - C++ DLL Library
 * Copyright (C) 2008 Little Apps (http://www.little-apps.org)
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#include "stdafx.h"

#ifdef UNICODE
	#define WIDEN2(x) L ## x
	#define WIDEN(x) WIDEN2(x)
	#define __WFILE__ WIDEN(__FILE__)
#endif

// Formats
#define FORMAT_XML 0
#define FORMAT_JSON 1

typedef void (__cdecl *fStartProc)(LPCTSTR, int, LPCTSTR, LPCTSTR); 
typedef void (__cdecl *fStopProc)(); 
typedef void (__cdecl *fEventProc)(LPCTSTR, LPCTSTR); 
typedef void (__cdecl *fEventValueProc)(LPCTSTR, LPCTSTR, LPCTSTR); 
typedef void (__cdecl *fEventPeriodProc)(LPCTSTR, LPCTSTR, int, BOOL); 
typedef void (__cdecl *fLogProc)(LPCTSTR); 
typedef void (__cdecl *fCustomDataProc)(LPCTSTR, LPCTSTR); 
typedef void (__cdecl *fLicenseProc)(TCHAR); 
typedef void (__cdecl *fExceptionProc)(LPCTSTR, LPCTSTR, LPCTSTR, LPCTSTR); 
typedef void (__cdecl *fInstallProc)(LPCTSTR, LPCTSTR); 
typedef void (__cdecl *fUninstallProc)(LPCTSTR, LPCTSTR); 

fStartProc fStart;
fStopProc fStop;
fEventProc fEvent;
fEventValueProc fEventValue;
fEventPeriodProc fEventPeriod;
fLogProc fLog;
fCustomDataProc fCustomData;
fLicenseProc fLicense;
fExceptionProc fException;
fInstallProc fInstall;
fUninstallProc fUninstall;

bool LoadDll() {
	HINSTANCE hInst = LoadLibrary(_T("LittleSoftwareStatsDLL.dll"));

	if (hInst != NULL) {
		if ((fStart = (fStartProc) GetProcAddress(hInst, "Start")) == NULL)
			return false;
		if ((fStop = (fStopProc) GetProcAddress(hInst, "Stop")) == NULL)
			return false;
		if ((fEvent = (fEventProc) GetProcAddress(hInst, "Event")) == NULL)
			return false;
		if ((fEventValue = (fEventValueProc) GetProcAddress(hInst, "EventValue")) == NULL)
			return false;
		if ((fEventPeriod = (fEventPeriodProc) GetProcAddress(hInst, "EventPeriod")) == NULL)
			return false;
		if ((fLog = (fLogProc) GetProcAddress(hInst, "Log")) == NULL)
			return false;
		if ((fCustomData = (fCustomDataProc) GetProcAddress(hInst, "CustomData")) == NULL)
			return false;
		if ((fLicense = (fLicenseProc) GetProcAddress(hInst, "License")) == NULL)
			return false;
		if ((fException = (fExceptionProc) GetProcAddress(hInst, "Exception")) == NULL)
			return false;
		if ((fInstall = (fInstallProc) GetProcAddress(hInst, "Install")) == NULL)
			return false;
		if ((fUninstall = (fUninstallProc) GetProcAddress(hInst, "Uninstall")) == NULL)
			return false;

		return true;
	}

	return false;
}

void Event() {
	// Event info
	const TCHAR szCategory[] = _T("Buttons");
	const TCHAR szEvent[] = _T("OK");

	// Send event
	fEvent(szCategory, szEvent);
}

void EventValue() {
	// Event value info
	const TCHAR szCategory[] = _T("View");
	const TCHAR szEventName[] = _T("Zoom");
	const TCHAR szEventValue[] = _T("In"); // Or Out

	// Send event value
	fEventValue(szCategory, szEventName, szEventValue);
}

void EventPeriod() {
	// Event period info
	const TCHAR szCategory[] = _T("Main");
	const TCHAR szEventName[] = _T("Scan");
	int nDuration = 60; // equals 60 seconds or 1 minute
	bool bCompleted = false;

	// Send event period
	fEventPeriod(szCategory, szEventName, nDuration, bCompleted);
}

void Log() {
	// Log message
	const TCHAR szLogMsg[] = _T("Hello World!");

	// Send message
	fLog(szLogMsg);
}

void CustomData() {
	// Custom data
	const TCHAR szCustomName[] = _T("Name");
	const TCHAR szCustomValue[] = _T("Joe Blow");

	// Send custom data
	fCustomData(szCustomName, szCustomValue);
}

void License() {
	// Software licenses
	TCHAR chLicenseFree = _T('F');
	TCHAR chLicenseDemo = _T('D');
	TCHAR chLicenseTrial = _T('T');
	TCHAR chLicenseRegistered = _T('R');
	TCHAR chLicenseCracked = _T('C');

	fLicense(chLicenseCracked);
}

int _tmain(int argc, _TCHAR* argv[]) {
	UNREFERENCED_PARAMETER(argc);
	UNREFERENCED_PARAMETER(argv);

	if (!LoadDll()) {
		_tprintf(_T("Unable to load DLL"));
		return -1;
	}

	// API info
	const TCHAR szApiUrl[] = _T(""); // URL to API (ie: http://YOURWEBSITEHERE/api.json)
	int nApiFormat = FORMAT_JSON; // Must correspond with extension in URL (FORMAT_XML or FORMAT_JSON)

	// Application info
	const TCHAR szAppId[] = _T(""); // Application ID (ie: 26ad4eb8f804200f1e23b27c1873d703)
	const TCHAR szAppVer[] = _T(""); // Application version (ie: 1.0)

	if (_tccmp(szApiUrl, _T("")) == 0) {
		_tprintf(_T("API URL cannot be empty"));
		return -1;
	}

	if (_tccmp(szAppId, _T("")) == 0) {
		_tprintf(_T("Application ID cannot be empty"));
		return -1;
	}

	if (_tccmp(szAppVer, _T("")) == 0) {
		_tprintf(_T("Application version cannot be empty"));
		return -1;
	}

	// Start tracking
	fStart(szApiUrl, nApiFormat, szAppId, szAppVer);

	Log();

	// Exceptions
	try {
		throw 20;
	} catch(...) {
		LPCTSTR szStackTrace = _T("N/A"); // Set stack trace to "n/a" since were unable to get a stack trace
		LPCTSTR szMessage = _T("Divide by zero");
		LPCTSTR szTarget = _T("");

		TCHAR szSource[512];
		ZeroMemory(szSource, 512);
#ifdef UNICODE
		_stprintf_s(szSource, 512, _T("%s %d"), __WFILE__, __LINE__);
#else
		_stprintf_s(szSource, 512, _T("%s %d"), __FILE__, __LINE__);
#endif

		fException(szMessage, szStackTrace, szSource, szTarget);
	}

	fStop();

	return 0;
}

LittleSoftwareStatsDLL Functions

There are other functions that can be utilized to collect data using LittleSoftwareStatsDLL.dll which are described below:

// Starts tracking software
// Example: Start(_T("http://stats.mywebsite.com/api.json"), FORMAT_JSON, _T("26ad4eb8f804200f1e23b27c1873d703"), _T("1.0"));
void Start(LPCTSTR szApiUrl, int nApiType, LPCTSTR szAppId, LPCTSTR szAppVer);

// Stops tracking software and sends data to API
// Example: Stop();
void Stop();

// Track an event
// Example: Event(_T("Events"), _T("Scan"));
void Event(LPCTSTR szCategoryName, LPCTSTR szEventName);

// Track an event value
// Example: EventValue(_T("Settings", _T("Theme"), _T("Blue"));
void EventValue(LPCTSTR szCategoryName, LPCTSTR szEventName, LPCTSTR szEventValue);

// Track an event period
// Example: EventPeriod(_T("Scans"), _T("Clean"), 360, TRUE);
void EventPeriod(LPCTSTR szCategoryName, LPCTSTR szEventName, int nEventDuration, BOOL bCompleted);

// Track a log message
// Example: Log(_T("Hello World!"));
void Log(LPCTSTR szLogMessage);

// Track software license
// License parameter ("chLicense") can be either 'F' (Free), 'T' (Trial), 'R' (Registered), 'D' (Demo), or 'C' (Cracked)
// Example: License(_T('F'));
void License(TCHAR chLicense);

// Track custom data
// Example: CustomData(_T("GFX Card Brand"), _T("NVIDIA"));
void CustomData(LPCTSTR szDataName, LPCTSTR szDataValue);

// Track an exception
// Example: Exception(_T("Divide by zero"), _T("N/A"), _T("Example.cpp 29"), _T(""));
void Exception(LPCTSTR szMessage, LPCTSTR szStackTrace, LPCTSTR szSource, LPCTSTR szTargetSite);

// Track an installation
// Example: Install(_T("26ad4eb8f804200f1e23b27c1873d703"), _T("1.0"));
void Install(LPCTSTR szAppId, LPCTSTR szAppVer);
// Track an uninstallation
// Example: Uninstall(_T("26ad4eb8f804200f1e23b27c1873d703"), _T("1.0"));
void Uninstall(LPCTSTR szAppId, LPCTSTR szAppVer);

Development Version

You can get the latest developer version of this library from the Bazaar VCS. This version is not recommended, but it does contain new features. You will need the Bazaar VCS to download the developer version.

You can get a copy of the branch using the command:

$ bzr branch lp:~lss-team/lilsoftstats/cppdll-library

You can also browse the source code here:
https://code.launchpad.net/~lss-team/lilsoftstats/cppdll-library

Notes

• This library should not require administrator privileges in order to work properly. However, the included DLL library has already been code signed just in case.
• If you need to make changes to the interaction with the API (such as how the response is handled), then you need to modify the code for the DLL.
• Due to the limitations of C++, you (usually) cannot use the stack trace when tracking exceptions with Little Software Stats.