In the app.js, we define our application namespace and import the logger and UI CommonJS modules.

//Create our application namespace
var my = {
  ui:{
    mainWindow : require('mainWin').createWindow()
  },
  logger : require('logger')
};

Next in our app.js, the setup method is called on the logger module. This ensures our database logging tables are created.

//Run setup to create our logging db
my.logger.setup();

The application-level listener is then defined in our app.js. This listener will wait for the app:log event to be fired and then call the logger's add method with the payload provided.

//Add a global event to listen for log messages
Ti.App.addEventListener('app:log',function(e){
  //Provide Log Message to CommonJS Logging Component
  my.logger.add(e);
});

//Open our sample window
my.ui.mainWindow.open();

The following code snippet demonstrates how to create the basic CommonJS module, logger.js, used in our global listener recipe. This module has two methods; setup, which creates our database objects, and add, which the listener calls to log our messages.

Create a constant with the logging database name.

var LOG_DB_NAME = "my_log_db";

Create the setup module-level method. This is used to create the LOG_HISTORY table, which will later be used to record all log statements.

exports.setup=function(){
  var createSQL = 'CREATE TABLE IF NOT EXISTS LOG_HISTORY '; 
  createSQL +='(LOG_NAME TEXT, LOG_MESSAGE TEXT, ';
  createSQL += 'LOG_DATE DATE)';
  //Install the db if needed
  var db = Ti.Database.open(LOG_DB_NAME);
  //Create our logging table if needed
  db.execute(createSQL);
  //Close the db
  db.close();
};

Create the add module-level method. This method is used to record the information to be added to the log table.

exports.add=function(logInfo){
  var insertSQL ="INSERT INTO LOG_HISTORY ";
  insertSQL +=" (LOG_NAME,LOG_MESSAGE,LOG_DATE)"; 
  insertSQL +=" "VALUES(?,?,?)";
  var db = Ti.Database.open(LOG_DB_NAME);
  //Create our logging table if needed
  db.execute(insertSQL,logInfo.name,logInfo.message, 
  new Date());
  //Close the db
  db.close();
};

The fetchWindow function returns a simple window demonstrating how to fire an application-level event. To demonstrate, a new message is sent each time, and we add a module level variable named _press_Count, which increments with each click.

Create the module-level variable _press_Count to record the number of times addLogButton has been pressed.

var _press_Count = 0;

The fetchWindow method returns a Ti.UI.Window containing the UI elements for this recipe.

exports.fetchWindow=function(){

A Ti.UI.Window is created for all of our UI elements to be attached.

  var win = Ti.UI.createWindow({
    backgroundColor:'#fff'
  });

The addLogButton Ti.UI.Button is created. This button will be used to trigger the Ti.App.fireEvent used to demonstrate global listeners in this recipe.

  var addLogButton = Ti.UI.createButton({
    title:"Fire Log Event", top:180, 
    left:5,right:5, height:50
  });

On clicking on the addLogButton button, the _press_Count variable is increased by one and a logging object is created. The following code demonstrates how the Ti.App.fireEvent method is called for the app:log event and a JavaScript object containing our logging details is provided. The listener we defined in our app.js will then receive this message and log our results.

  addLogButton.addEventListener('click',function(e){		

The first action taken after the user taps the addLogButton is to increase the _pressCount by one.

    _press_Count ++;

Next the logObject containing information to be submitted for logging is created.

    var logObject = {
      name:'test log',
      message:'example message ' + 
      _press_Count
    };

Finally, the Ti.App.fireEvent is called for the app:log event. The logObject is also provided as a parameter when calling this application global event.

    Ti.App.fireEvent('app:log',logObject);
  });    
  win.add(addLogButton);
    
  //Return window
  return win;
};