[TIMOB-25478] Hyperloop: iOS - Cannot use Hyperloop.defineClass with a Classic (Non-Alloy) project

   /**
    * @author Kon Lovett
    */
   
   var CentralManagerDelegate = Hyperloop.defineClass('CentralManagerDelegate', 'NSObject', ['CBCentralManagerDelegate']);
   
   CentralManagerDelegate.addMethod({
       selector : 'centralManagerDidUpdateState:',
       instance : true,
       arguments : ['CBCentralManager'],
       callback : function(central) {
           if (this.didUpdateState) {
               return this.didUpdateState(central);
           }
       }
   });
   
   CentralManagerDelegate.addMethod({
       selector : 'centralManager:willRestoreState:',
       instance : true,
       arguments : ['CBCentralManager', 'NSDictionary'],
       callback : function(central, dict) {
           if (this.willRestoreState) {
               return this.willRestoreState(central, dict);
           }
       }
   });
   
   CentralManagerDelegate.addMethod({
       selector : 'centralManager:didDiscoverPeripheral:advertisementData:RSSI:',
       instance : true,
       arguments : ['CBCentralManager', 'CBPeripheral', 'NSDictionary', 'NSNumber'],
       callback : function(central, peripheral, advertisementData, RSSI) {
           if (this.didDiscoverPeripheral) {
               return this.didDiscoverPeripheral(central, peripheral, advertisementData, RSSI);
           }
       }
   });
   
   CentralManagerDelegate.addMethod({
       selector : 'centralManager:didConnectPeripheral:',
       instance : true,
       arguments : ['CBCentralManager', 'CBPeripheral'],
       callback : function(central, peripheral) {
           if (this.didConnectPeripheral) {
               return this.didConnectPeripheral(central, peripheral);
           }
       }
   });
   
   CentralManagerDelegate.addMethod({
       selector : 'centralManager:didFailToConnectPeripheral:error:',
       instance : true,
       arguments : ['CBCentralManager', 'CBPeripheral', 'NSError'],
       callback : function(central, peripheral, error) {
           if (this.didFailToConnectPeripheral) {
               return this.didFailToConnectPeripheral(central, peripheral, error);
           }
       }
   });
   
   CentralManagerDelegate.addMethod({
       selector : 'centralManager:didDisconnectPeripheral:error:',
       instance : true,
       arguments : ['CBCentralManager', 'CBPeripheral', 'NSError'],
       callback : function(central, peripheral, error) {
           if (this.didDisconnectPeripheral) {
               return this.didDisconnectPeripheral(central, peripheral, error);
           }
       }
   });
   
   module.exports = CentralManagerDelegate;
   

   /**
    * @author Kon Lovett
    */
   
   /* */
   
   var CBCentralManager = require('CoreBluetooth/CBCentralManager');
   var CBUUID = require('CoreBluetooth/CBUUID');
   
   var _ = require('underscore');
   
   //relative load
   var CentralManagerDelegate = require('centralmanagerdelegate');
   
   /*
   * Module Init
   */
   
   // CM delegate define
   var cenManDel = new CentralManagerDelegate();
   cenManDel.didUpdateState = didUpdateState;
   cenManDel.willRestoreState = willRestoreState;
   cenManDel.didDiscoverPeripheral = didDiscoverPeripheral;
   cenManDel.didConnectPeripheral = didConnectPeripheral;
   cenManDel.didFailToConnectPeripheral = didFailToConnectPeripheral;
   cenManDel.didDisconnectPeripheral = didDisconnectPeripheral;
   
   var centralManager = CBCentralManager.alloc().initWithDelegateQueueOptions(cenManDel, null, null);
   
   var kindsMatcher;
   
   /* */
   
   // kinds : [ string ]
   function scan(kinds) {
   
       Ti.API.info('Scanning Desired');
   
       // look for all or a subset of peripherals
       var nativeKinds = null;
       if (!(kinds || kindsMatcher) || !kindsMatcher(kinds)) {
           kindsMatcher = null;
           if (kinds) {
               kindsMatcher = _.matcher(kinds);
               nativeKinds = _.map(kinds, function(uuidStr) {
                   return CBUUID.UUIDWithString(uuidStr);
               });
           }
       }
   
       centralManager.scanForPeripheralsWithServicesOptions(nativeKinds, null);
   
       Ti.API.info('Scanning Started');
   }
   
   /* Delegate Callbacks */
   
   function didUpdateState(central) {
       Ti.API.info('didUpdateState');
   };
   
   function willRestoreState(central, dict) {
       Ti.API.info('willRestoreState');
       Ti.API.info('dict: ' + JSON.strfingify(dict, null, 4));
   };
   
   function didDiscoverPeripheral(central, peripheral, advertisementData, RSSI) {
       Ti.API.info('didDiscoverPeripheral');
       Ti.API.info('peripheral: ' + JSON.stringify(peripheral, null, 4));
       Ti.API.info('advertisementData: ' + JSON.stringify(advertisementData, null, 4));
       Ti.API.info('RSSI: ' + JSON.stringify(RSSI, null, 4));
   };
   
   function didConnectPeripheral(central, peripheral) {
       Ti.API.info('didConnectPeripheral');
       Ti.API.info('peripheral: ' + JSON.stringify(peripheral, null, 4));
   };
   
   function didFailToConnectPeripheral(central, peripheral, error) {
       Ti.API.info('didFailToConnectPeripheral');
       Ti.API.info('peripheral: ' + JSON.stringify(peripheral, null, 4));
       Ti.API.info('error: ' + JSON.stringify(error, null, 4));
   };
   
   function didDisconnectPeripheral(central, peripheral, error) {
       Ti.API.info('didDisconnectPeripheral');
       Ti.API.info('peripheral: ' + JSON.stringify(peripheral, null, 4));
       Ti.API.info('error: ' + JSON.stringify(error, null, 4));
   };
   
   /* */
   
   exports.scan = scan;
   

   /*
    * Single Window Application Template:
    * A basic starting point for your application.  Mostly a blank canvas.
    *
    * In app.js, we generally take care of a few things:
    * - Bootstrap the application with any data we need
    * - Check for dependencies like device type, platform version or network connection
    * - Require and open our top-level UI component
    *
    */
   
   //bootstrap and check dependencies
   if (Ti.version < 1.8) {
     alert('Sorry - this application template requires Titanium Mobile SDK 1.8 or later');
   }
   
   // This is a single context application with multiple windows in a stack
   (function() {
     //render appropriate components based on the platform and form factor
     var osname = Ti.Platform.osname,
       version = Ti.Platform.version,
       height = Ti.Platform.displayCaps.platformHeight,
       width = Ti.Platform.displayCaps.platformWidth;
   
     //considering tablets to have width over 720px and height over 600px - you can define your own
     function checkTablet() {
       var platform = Ti.Platform.osname;
   
       switch (platform) {
         case 'ipad':
           return true;
         case 'android':
           var psc = Ti.Platform.Android.physicalSizeCategory;
           var tiAndroid = Ti.Platform.Android;
           return psc === tiAndroid.PHYSICAL_SIZE_CATEGORY_LARGE || psc === tiAndroid.PHYSICAL_SIZE_CATEGORY_XLARGE;
         default:
           return Math.min(
             Ti.Platform.displayCaps.platformHeight,
             Ti.Platform.displayCaps.platformWidth
           ) >= 400;
       }
     }
   
     var isTablet = checkTablet();
     console.log(isTablet);
   
     var Window;
     if (isTablet) {
       Window = require('ui/tablet/ApplicationWindow');
     } else {
       // Android uses platform-specific properties to create windows.
       // All other platforms follow a similar UI pattern.
       if (osname === 'android') {
         Window = require('ui/handheld/android/ApplicationWindow');
       } else {
         Window = require('ui/handheld/ApplicationWindow');
       }
     }
     new Window().open();
     
     // pulled from iphone/ or android/ into toplevel depending on OS
     var CentralBLE = require('centralble');
     CentralBLE.scan();
     
   })();
   
   

    / ES6+
    import { UIButton } from 'UIKit';
    
    // ES5
    const UIButton = require('UIKit/UIButton');
    

    var CBCentralManager = require('CoreBluetooth/CBCentralManager');
    var CentralManagerDelegate = require('centralmanagerdelegate');
    var cenManDel = new CentralManagerDelegate();
    var centralManager = CBCentralManager.alloc().initWithDelegateQueueOptions(cenManDel, null, null);