void handleConnectionError(DicePlus dpf)
    {
        if (dpf.Equals(currentlyConnectedDie))
        {
            if (state == State.CONNECTING)
            {
                setState(State.DISCONNECTED);
            }
            currentlyConnectedDie = null;
        }
        if (connectedDice.Contains(dpf))
        {
            connectedDice.Remove(dpf);
        }
        if (state == State.CONNECTED)
        {
            if (connectedDice.Count < maxDiceCount)
            {
                DicePlusAnimator.Instance.runDisconnectedAnimation();
                setState(State.DISCONNECTED);
            }
        }
        else if (state != State.ROLLER)
        {
            OrbitingButtonsManager.Instance.showButtons(true);
//			triedDiceSet.Add(dpf);
        }
    }
    public void onConnectionEstablished(DicePlus dpe)
    {
        if (dpe.Equals(currentlyConnectedDie))
        {
            currentlyConnectedDie = null;
        }

        SoftwareVersion sv = dpe.getSoftwareVersion();

        if ((sv.getMajor() > major) || (sv.getMajor() == major && sv.getMinor() >= minor))
        {
            connectedDice.Add(dpe);
            if (connectedDice.Count >= maxDiceCount)
            {
                setState(State.CONNECTED);
            }
            else
            {
                setState(State.DISCONNECTED);
            }
            DicePlusAnimator.Instance.runConnectedAnimation();
            dpe.subscribeRolls();
            dpe.subscribeBatteryState();
            dpe.registerListener(this);
            rssi = dpe.rssi;
        }
        else
        {
            setState(State.DISCONNECTED);
            DicePlusAnimator.Instance.runVersionMissmatchAnimation(false);
            dpe.disconnect();
        }
    }
 public override void onRoll(DicePlus dicePlus, long time, int duration, int face, int invalidityFlags, string errorMsg)
 {
     // Accepting only valid rolls.
     if(invalidityFlags == 0) {
     //			RollResult.text = face.ToString();
     }
 }
 public void onConnectionFailed(DicePlus dpf, int errorCode, string excpMsg)
 {
     if (errorCode == DicePlusConnector.ERR_VERSION_MISSMATCH)
     {
         DicePlusAnimator.Instance.runVersionMissmatchAnimation(true);
     }
     handleConnectionError(dpf);
 }
    public override void onRoll(DicePlus dicePlus, long time, int duration, int face, int invalidityFlags, string errorMsg)
    {
        // Accepting only valid rolls.
        if (invalidityFlags == 0)
        {
//			RollResult.text = face.ToString();
        }
    }
    public override void onOrientationReadout(DicePlus dicePlus, long time, Vector3 v, string errorMsg)
    {
        // X axis goes through 1
        // Y axis goes through 5
        // Z axis goes through 3
//		transform.rotation = Quaternion.Euler(Vector3.zero);
//		transform.Rotate(v);
        currentOrientation = v;
    }
 public override void onOrientationReadout(DicePlus dicePlus, long time, Vector3 v, string errorMsg)
 {
     // X axis goes through 1
     // Y axis goes through 5
     // Z axis goes through 3
     //		transform.rotation = Quaternion.Euler(Vector3.zero);
     //		transform.Rotate(v);
     currentOrientation = v;
 }
Ejemplo n.º 8
0
    void IDicePlusConnectorListener.onConnectionEstablished(DicePlus dicePlus)
    {
        dicePlus.initializePStorageCommunication();
        dicePlus.registerListener(this);
        dicePlus.subscribeOrientationReadouts(20);

        myDice = dicePlus;
        DiceConnected = true;
    }
 private void checkConnection()
 {
     if (state == State.SEARCHING)
     {
         if (rssiSearchTimoutTime < Time.time && diceSet.Count > 0)
         {
             setState(State.DISCONNECTED);
             DicePlusConnector.Instance.stopScan();
         }
     }
     if (state == State.DISCONNECTED)
     {
         if (diceSet.Count == 0)
         {
             if (scanningEnabled)
             {
                 if (DicePlusConnector.Instance.startScan())
                 {
                     rssiSearchTimoutTime = Time.time + findClosestTime;
                     setState(State.SEARCHING);
                 }
                 else
                 {
                     OrbitingButtonsManager.Instance.showButtons(true);
                     setState(State.DISCONNECTED);
                 }
             }
         }
         else
         {
             int      highestRssi   = int.MinValue;
             DicePlus toBeConnected = null;
             foreach (DicePlus dp in diceSet)
             {
                 if (dp.rssi > highestRssi)
                 {
                     highestRssi   = dp.rssi;
                     toBeConnected = dp;
                 }
             }
             if (toBeConnected != null)
             {
                 currentlyConnectedDie = toBeConnected;
                 DicePlusConnector.Instance.connect(toBeConnected);
                 setState(State.CONNECTING);
                 diceSet.Remove(toBeConnected);
             }
         }
     }
 }
    public void onNewDie(DicePlus ndp)
    {
        if (
            !connectedDice.Contains(ndp))
        {
            diceSet.Add(ndp);

            if (ndp.rssi >= rssi - 5)
            {
                setState(State.DISCONNECTED);
                DicePlusConnector.Instance.stopScan();
            }
        }
    }
 public override void onBatteryState(DicePlus dicePlus, DicePlusConnector.BatteryState batteryState, int percentage, bool low, string errorMsg)
 {
     if (percentage < battery && low)
     {
         if (state != State.CONNECTED)
         {
             DicePlusAnimator.Instance.runLowBatteryAnimation();
         }
         else
         {
             StartCoroutine(DicePlusAnimator.Instance.lowBatteryCorutine());
         }
         battery = percentage;
     }
 }
    /// <summary>
    /// Subscribes to accelerometer readouts and configure sensor
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='readFrequency'>
    /// readout frequency (in Hz), values: 1 - 60
    /// </param>
    /// <param name='readoutType'>
    /// a readout filter type
    /// </param>
    public void subscribeAccelerometerReadouts(DicePlus dicePlus, int readFrequency, AccelerometerReadoutType readoutType)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_subscribeAndConfigureAccelerometerReadouts(dicePlus.address, readFrequency, (int)readoutType);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("subscribeAndConfigureAccelerometerReadouts", new object [] {dicePlus.address, readFrequency, (int)readoutType});
        }
        #endif
    }
    /// <summary>
    /// Sends setMode packet to the given die
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='mode'>
    /// mode to set
    /// </param>
    public void setMode(DicePlus dicePlus, DieMode mode)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_setMode(dicePlus.address, (int)mode);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("setMode", new object [] {dicePlus.address, (int)mode});
        }
        #endif
    }
    /// <summary>
    /// Sends fade LED animation request
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='ledMask'>
    /// which LEDs to run animation on
    /// </param>
    /// <param name='priority'>
    /// animation with lower value overrides other, values: 0 - 255
    /// </param>
    /// <param name='color'>
    /// color to be faded
    /// </param>
    /// <param name='fadeInOutTime'>
    /// time in ms LED is fading in/out, values: 0 - 65535
    /// </param>
    /// <param name='pauseTime'>
    /// time in ms LED stays at full bright before fading out, values: 0 - 65535
    /// </param>
    public void runFadeAnimation(DicePlus dicePlus, LedFace ledMask, int priority, 
			Color color, int fadeInOutTime, int pauseTime)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_runFadeAnimation(dicePlus.address, (int)ledMask, priority, (int)(color.r*255), (int)(color.g*255), (int)(color.b*255), fadeInOutTime, pauseTime);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("runFadeAnimation", new object [] {dicePlus.address, (int)ledMask, priority, (int)(color.r*255), (int)(color.g*255), (int)(color.b*255), fadeInOutTime, pauseTime});
        }
        #endif
    }
 public virtual void onPStorageValueRead(DicePlus dicePlus, int handle, int intvalue)
 {
 }
 public virtual void onAccelerometerReadout(DicePlus dicePlus, long time, Vector3 v, int type, string errorMsg)
 {
 }
    /// <summary>
    /// Checks if the die is connected and authenticated
    /// </summary>
    /// <returns>
    /// true, if the die is authenticated; false otherwise.
    /// </returns>
    /// <param name='dicePlus'>
    /// the dice
    /// </param>
    public bool hasConnectionEstabilished(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        return ios_connected(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            return dmo.Call<bool>("hasConnectionEstabilished", new object [] {dicePlus.address});
        }
        #endif
        return false;
    }
    /// <summary>
    /// Gets persistent storage record description for given handle
    /// </summary>
    /// <returns>
    /// persistent storage record description, null if handle was invalid
    /// </returns>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='handle'>
    /// the handle to requested record
    /// </param>
    public PStorageRecordDescription getPStorageRecordDescription(DicePlus dicePlus, int handle)
    {
        string result = null;
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        result = ios_getPStorageRecordDescription(dicePlus.address, handle);
        #elif UNITY_ANDROID

        if (dmo != null) {
            result = dmo.Call<string>("getPStorageRecordDescription", new object [] {dicePlus.address, handle});
        }
        #endif
        PStorageRecordDescription retVal;
        if (result == null || result.Equals("") || !PStorageRecordDescription.TryParse(result, out retVal)) {
            return null;
        } else {
            return retVal;
        }
    }
 public void onConnectionLost(DicePlus dpl)
 {
     handleConnectionError(dpl);
 }
 public virtual void onPowerMode(DicePlus dicePlus, long time, DicePlusConnector.PowerMode mode, string errorMsg)
 {
 }
 public virtual void onPStorageOperationFailed(DicePlus dicePlus, string errorMsg)
 {
 }
 public virtual void onPStorageCommunicationInitialized(DicePlus dicePlus, int count)
 {
 }
    /// <summary>
    /// Subscribes to proximity readouts and configures sensor
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='freq'>
    /// readout frequency (in Hz), values: 1 - 10
    /// </param>
    public void subscribeProximityReadouts(DicePlus dicePlus, int freq)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_subscribeAndConfigureProximityReadouts(dicePlus.address, freq);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("subscribeAndConfigureProximityReadouts", new object [] {dicePlus.address, freq});
        }
        #endif
    }
 public virtual void onReadoutFailed(DicePlus dicePlus, int dataSourceCode, string errorMsg)
 {
 }
 public virtual void onPStorageValueRead(DicePlus dicePlus, int handle, String str)
 {
 }
 public virtual void onSubscriptionChangeStatus(DicePlus dicePlus, DicePlusConnector.DataSource dataSourceCode, string errorMsg)
 {
 }
    /// <summary>
    /// Gets the status.
    /// </summary>
    /// <returns>
    /// dies module status
    /// </returns>
    /// <param name='dicePlus'>
    /// the dice
    /// </param>
    public int? getStatus(DicePlus dicePlus)
    {
        string result = null;
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        result = ios_getStatus(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            result = dmo.Call<string>("getStatus", new object [] {dicePlus.address});
        }
        #endif
        int retVal = new int();
        if (result == null || result.Equals("") || !int.TryParse(result, out retVal)) {
            return null;
        } else {
            return retVal;
        }
    }
Ejemplo n.º 28
0
 public virtual void onConnectionEstablished(DicePlus dicePlus)
 {
 }
    /// <summary>
    /// Sends request to the given dice to get persistent storage record value
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='handle'>
    /// the handle to requested record
    /// </param>
    public void readPStorageValue(DicePlus dicePlus, int handle)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_readPStorageValue(dicePlus.address, handle);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("readPStorageValue", new object [] {dicePlus.address, handle});
        }
        #endif
    }
Ejemplo n.º 30
0
 public virtual void onNewDie(DicePlus dicePlus)
 {
 }
Ejemplo n.º 31
0
 public virtual void onConnectionLost(DicePlus dicePlus)
 {
 }
 public virtual void onPStorageValueRead(DicePlus dicePlus, int handle, Vector3 vector)
 {
 }
Ejemplo n.º 33
0
 public virtual void onConnectionFailed(DicePlus dicePlus, int errorCode, string excpMsg)
 {
 }
 public virtual void onDiceStatistics(DicePlus dicePlus, DiceStatistics diceStatistics, string errorMsg)
 {
 }
    /// <summary>
    /// Sends blink LED animation request
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='ledMask'>
    /// which LEDs to run animation on
    /// </param>
    /// <param name='priority'>
    /// animation with lower value overrides other, values: 0 - 255
    /// </param>
    /// <param name='color'>
    /// color to be blinked
    /// </param>
    /// <param name='ledOnPeriod'>
    /// time in ms LED is ON, values: 0 - 65535
    /// </param>
    /// <param name='ledCyclePeriod'>
    /// time in ms one blink cycle lasts, values: 0 - 65535
    /// </param>
    /// <param name='blinkNumber'>
    /// number of blinks, values: 0 - 255
    /// </param>
    public void runBlinkAnimation(DicePlus dicePlus, LedFace ledMask, int priority, 
			Color color, int ledOnPeriod, int ledCyclePeriod, int blinkNumber)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_runBlinkAnimation(dicePlus.address, (int)ledMask, priority, (int)(color.r*255), (int)(color.g*255), (int)(color.b*255), ledOnPeriod, ledCyclePeriod, blinkNumber);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("runBlinkAnimation", new object [] {dicePlus.address, (int)ledMask, priority, (int)(color.r*255), (int)(color.g*255), (int)(color.b*255), ledOnPeriod, ledCyclePeriod, blinkNumber});
        }
        #endif
    }
    /// <summary>
    /// Unsubscribes from battery state events
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void unsubscribeBatteryState(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_unsubscribeBatteryState(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("unsubscribeBatteryState", new object [] {dicePlus.address});
        }
        #endif
    }
    /// <summary>
    /// Sends standard LED animation request
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='ledMask'>
    /// which LEDs to run animation on
    /// </param>
    /// <param name='priority'>
    /// animation with lower value overrides other, values: 0 - 255
    /// </param>
    /// <param name='animation'>
    /// standard animation type
    /// </param>
    public void runStandardAnimation(DicePlus dicePlus, LedFace ledMask, int priority, 
			DicePlusConnector.AnimationType animation)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_runStandardAnimation(dicePlus.address, (int)ledMask, priority, (int)animation);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("runStandardAnimation", new object [] {dicePlus.address, (int)ledMask, priority, (int)animation});
        }
        #endif
    }
    /// <summary>
    /// Sends request to the given dice to set persistent storage record value
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='handle'>
    /// the handle to requested record
    /// </param>
    /// <param name='x'>
    /// first vector value to be set
    /// </param>
    /// <param name='y'>
    /// second vector value to be set
    /// </param>
    /// <param name='z'>
    /// third vector value to be set
    /// </param>
    public void writePStorageValue(DicePlus dicePlus, int handle, int x, int y, int z)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_writePStorageVecValue(dicePlus.address, handle, x, y, z);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("writePStorageVecValue", new object [] {dicePlus.address, handle, x, y, z});
        }
        #endif
    }
    /// <summary>
    /// Sends sleep request to the given dice
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void sleep(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_sleep(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("sleep", new object [] {dicePlus.address});
        }
        #endif
    }
    void onNewDie(string str)
    {
        string[] words = str.Split('#');
        string addres = words[0];

        DicePlus dicePlus;
        if (dice.ContainsKey(addres)) {
            dicePlus = dice[addres];
        } else {
            dicePlus = new DicePlus(this, addres);
            dice.Add(addres, dicePlus);
        }
        dicePlus.rssi = int.Parse(words[1]);
        foreach (IDicePlusConnectorListener listener in listeners) {
            listener.onNewDie(dicePlus);
        }
    }
    /// <summary>
    /// Subscribes to magnetometer readouts and configures sensor.
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='freq'>
    /// readout frequency (in Hz), values: 1 - 30
    /// </param>
    /// <param name='type'>
    /// a readout type
    /// </param>
    public void subscribeMagnetometerReadouts(DicePlus dicePlus, int freq, MagnetometerReadoutType type)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_subscribeAndConfigureMagnetometerReadouts(dicePlus.address, freq, (int)type);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("subscribeAndConfigureMagnetometerReadouts", new object [] {dicePlus.address, freq, (int)type});
        }
        #endif
    }
    /// <summary>
    /// Sends the die statistics request to the given dice.
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void getDiceStatistics(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_getDiceStatistics(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("getDiceStatistics", new object [] {dicePlus.address});
        }
        #endif
    }
    /// <summary>
    /// Subscribes to roll events
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void subscribeRolls(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_subscribeRolls(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("subscribeRolls", new object [] {dicePlus.address});
        }
        #endif
    }
 public virtual void onPStorageReset(DicePlus dicePlus, string errorMsg)
 {
 }
    /// <summary>
    /// Unsubscribes from touch/release state events
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void unsubscribeTouchReadouts(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_unsubscribeTouchReadouts(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("unsubscribeTouchReadouts", new object [] {dicePlus.address});
        }
        #endif
    }
 public override void onLedState(DicePlus dicePlus, long time, DicePlusConnector.LedFace ledMask, long animationId, int type, string errorMsg)
 {
 }
    /// <summary>
    /// Sends request to the given dice to set persistent storage record value
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    /// <param name='handle'>
    /// the handle to requested record
    /// </param>
    /// <param name='str'>
    /// string value to be set
    /// </param>
    public void writePStorageValue(DicePlus dicePlus, int handle, string str)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_writePStorageStrValue(dicePlus.address, handle, str);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("writePStorageStrValue", new object [] {dicePlus.address, handle, str});
        }
        #endif
    }
    public void onNewDie(DicePlus dicePlus)
    {
//		throw new System.NotImplementedException ();
    }
    /// <summary>
    /// Disconnects specified dice.
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void disconnect(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_disconnect(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("disconnect", new object [] {dicePlus.address});
        }
        #endif
    }
 public void onConnectionLost(DicePlus dicePlus)
 {
     dicePlus.unsubscribeOrientationReadouts();
 }
    /// <summary>
    /// Gets device model number
    /// </summary>
    /// <returns>
    /// device model model, null when die has not yet connected and authenticated connection.
    /// </returns>
    /// <param name='dicePlus'>
    /// the dice
    /// </param>
    public long? getModelNumber(DicePlus dicePlus)
    {
        string result = null;
        #if UNITY_EDITOR

        #elif UNITY_IPHONE
        result = ios_getModelNumber(dicePlus.address);
        #elif UNITY_ANDROID
        if (dmo != null) {
            result = dmo.Call<string>("getModelNumber", new object [] {dicePlus.address});
        }
        #endif
        long retVal = new long();
        if (result == null || result.Equals("") || !long.TryParse(result, out retVal)) {
            return null;
        } else {
            return retVal;
        }
    }
    public void onConnectionEstablished(DicePlus dicePlus)
    {
        dicePlus.registerListener(this);
        dicePlus.subscribeOrientationReadouts(20);
//		dicePlus.subscribeLedState();
    }
    /// <summary>
    /// Gets software version.
    /// </summary>
    /// <returns>
    /// number representing software version, null when die has not yet connected and authenticated connection.
    /// </returns>
    /// <param name='dicePlus'>
    /// the dice
    /// </param>
    public SoftwareVersion getSoftwareVersion(DicePlus dicePlus)
    {
        string result = null;
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        result = ios_getSoftwareVersion(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            result = dmo.Call<string>("getSoftwareVersion", new object [] {dicePlus.address});
        }
        #endif
        if (result == null || result.Equals("")) {
            return null;
        } else {
            return SoftwareVersion.Parse(result);
        }
    }
    public void onConnectionFailed(DicePlus dicePlus, int errorCode, string excpMsg)
    {
//		throw new System.NotImplementedException ();
    }
    /// <summary>
    /// Gets dice unique identifier
    /// </summary>
    /// <returns>
    /// unique identifier string, null when die has not yet connected and authenticated connection.
    /// </returns>
    /// <param name='dicePlus'>
    /// the die
    /// </param>
    public string getUID(DicePlus dicePlus)
    {
        string result = null;
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        result = ios_getUID(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            result = dmo.Call<string>("getUID", new object [] {dicePlus.address});
        }
        #endif
        if (result == null || result.Equals("")) {
            return null;
        } else {
            return result;
        }
    }
 public virtual void onConnectionLost(DicePlus dicePlus)
 {
 }
    /// <summary>
    /// Sends request to the given dice to initialize persistent storage communication
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void initializePStorageCommunication(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_initializePStorageCommunication(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("initializePStorageCommunication", new object [] {dicePlus.address});
        }
        #endif
    }
 public virtual void onNewDie(DicePlus dicePlus)
 {
 }
    /// <summary>
    /// Sends request to the given dice to reset all persistent storage settings
    /// </summary>
    /// <param name='dicePlus'>
    /// the die to which to send command/request
    /// </param>
    public void resetPStorage(DicePlus dicePlus)
    {
        #if UNITY_EDITOR

        #elif UNITY_IPHONE

        ios_resetPStorage(dicePlus.address);
        #elif UNITY_ANDROID

        if (dmo != null) {
            dmo.Call("resetPStorage", new object [] {dicePlus.address});
        }
        #endif
    }
 public virtual void onSleepStatus(DicePlus dicePlus, string errorMsg)
 {
 }