/// <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);
}
}
public void init()
{
if (state_ != PutBytesState.NotStarted)
{
HasError = true;
throw new Exception("Already init()ed");
}
byte[] data = Util.Pack("!bIbb", 1, buffer_.Length, transferType_, index_);
pebble_.RegisterEndpointCallback(Endpoints.PUT_BYTES, PutBytesReceived);
pebble_.sendMessage(Endpoints.PUT_BYTES, data);
var wait = new EndpointSync <AppbankInstallMessageEventArgs>(pebble_, Endpoints.PUT_BYTES);
state_ = PutBytesState.WaitForToken;
}
/// <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();
}
}
}