/// <summary> Get the Pebble's version info. </summary> /// <param name="async">If true, return immediately. If false, wait until the response /// has been received.</param> public void GetVersion(Boolean async = false) { byte[] data = { 0 }; sendMessage(Endpoints.VERSION, data); if (!async) { var wait = new EndpointSync <MessageReceivedEventArgs>(this, Endpoints.VERSION); wait.WaitAndReturn(timeout: 5000); } }
/// <summary> /// Fetch the contents of the Appbank. /// </summary> /// <param name="async">When true, this returns null immediately. Otherwise it waits for the event and sends /// the appropriate AppbankContentsReceivedEventArgs.</param> /// <returns></returns> public AppbankContentsReceivedEventArgs GetAppbankContents(bool async = false) { sendMessage(Endpoints.APP_MANAGER, new byte[] { 1 }); if (!async) { var wait = new EndpointSync <AppbankContentsReceivedEventArgs>(this, Endpoints.APP_MANAGER); return(wait.WaitAndReturn()); } else { return(null); } }
/// <summary> /// Get the time from the connected Pebble. /// </summary> /// <param name="async">When true, this returns null immediately. Otherwise it waits for the event and sends /// the appropriate TimeReceivedEventArgs.</param> /// <returns>A TimeReceivedEventArgs with the time, or null.</returns> public TimeReceivedEventArgs GetTime(bool async = false) { byte[] data = { 0 }; sendMessage(Endpoints.TIME, data); if (!async) { var wait = new EndpointSync <TimeReceivedEventArgs>(this, Endpoints.TIME); return(wait.WaitAndReturn()); } else { return(null); } }
/// <summary> /// Remove an app from the Pebble, using an App instance retrieved from the Appbank. /// </summary> /// <param name="app"></param> /// <param name="async">When true, this returns null immediately. Otherwise it waits for the event and sends /// the appropriate AppbankInstallMessageEventArgs.</param> /// <returns></returns> public AppbankInstallMessageEventArgs RemoveApp(AppBank.App app, bool async = false) { var msg = Util.Pack("!bII", 2, app.ID, app.Index); sendMessage(Endpoints.APP_MANAGER, msg); if (!async) { var wait = new EndpointSync <AppbankInstallMessageEventArgs>(this, Endpoints.APP_MANAGER); return(wait.WaitAndReturn()); } else { return(null); } }
/// <summary> Send the Pebble a ping. </summary> /// <param name="cookie"></param> /// <param name="async">If true, return null immediately and let the caller wait for a PING event. If false, /// wait for the reply and return the PingReceivedEventArgs.</param> public PingReceivedEventArgs Ping(UInt32 cookie = 0, Boolean async = false) { byte[] _cookie = new byte[5]; // No need to worry about endianness as it's sent back byte for byte anyway. Array.Copy(BitConverter.GetBytes(cookie), 0, _cookie, 1, 4); sendMessage(Endpoints.PING, _cookie); if (!async) { var wait = new EndpointSync <PingReceivedEventArgs>(this, Endpoints.PING); return(wait.WaitAndReturn(timeout: 10000)); } else { return(null); } }
/// <summary> Recurring prod to check whether the Pebble is still connected and responding. /// </summary> /// <remarks> /// Ugly hack? Yes. It might be possible to do this more properly with the 32feet.NET bt lib. /// </remarks> /// <param name="sender"></param> /// <param name="e"></param> void pingTimer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { if (Alive) { byte[] data = { 0 }; try { sendMessage(Endpoints.TIME, data); var wait = new EndpointSync <TimeReceivedEventArgs>(this, Endpoints.TIME); wait.WaitAndReturn(timeout: PingTimeout); } catch (TimeoutException) { Disconnect(); } } }