Async await everything

Author: golf1052

libsignal-service-dotnet/SignalServiceAccountManager.cs

@@ -52,7 +52,6 @@ public SignalServiceAccountManager(SignalServiceConfiguration configuration,
         /// Construct a SignalServiceAccountManager for linking as a slave device
         /// </summary>
         /// <param name="configuration">The URL configuration for the Signal Service</param>
-        /// <param name="token">The cancellation token for the ProvisioningSocket</param>
         /// <param name="userAgent">A string which identifies the client software</param>
         public SignalServiceAccountManager(SignalServiceConfiguration configuration, string userAgent)
         {
@@ -66,28 +65,32 @@ public SignalServiceAccountManager(SignalServiceConfiguration configuration, str
         /// 
         /// </summary>
         /// <param name="pin"></param>
-        public void SetPin(string pin)
+        public async Task SetPin(string pin)
         {
             if (pin != null)
-                PushServiceSocket.SetPin(pin);
+            {
+                await PushServiceSocket.SetPin(pin);
+            }
             else
-                PushServiceSocket.RemovePin();
+            {
+                await PushServiceSocket.RemovePin();
+            }
         }
 
         /// <summary>
         /// Register/Unregister a Google Cloud Messaging registration ID.
         /// </summary>
         /// <param name="gcmRegistrationId">The GCM id to register.  A call with an absent value will unregister.</param>
         /// <returns></returns>
-        public void SetGcmId(May<string> gcmRegistrationId)// throws IOException
+        public async Task SetGcmId(May<string> gcmRegistrationId)// throws IOException
         {
             if (gcmRegistrationId.HasValue)
             {
-                this.PushServiceSocket.RegisterGcmId(gcmRegistrationId.ForceGetValue());
+                await PushServiceSocket.RegisterGcmId(gcmRegistrationId.ForceGetValue());
             }
             else
             {
-                this.PushServiceSocket.UnregisterGcmId();
+                await PushServiceSocket.UnregisterGcmId();
             }
         }
 
@@ -96,19 +99,19 @@ public void SetGcmId(May<string> gcmRegistrationId)// throws IOException
         /// an SMS verification code to this Signal user.
         /// </summary>
         /// <returns></returns>
-        public void RequestSmsVerificationCode()// throws IOException
+        public async Task RequestSmsVerificationCode()// throws IOException
         {
-            this.PushServiceSocket.CreateAccount(false);
+            await PushServiceSocket.CreateAccount(false);
         }
 
         /// <summary>
         /// Request a Voice verification code.  On success, the server will
         /// make a voice call to this Signal user.
         /// </summary>
         /// <returns></returns>
-        public void RequestVoiceVerificationCode()// throws IOException
+        public async Task RequestVoiceVerificationCode()// throws IOException
         {
-            this.PushServiceSocket.CreateAccount(true);
+            await PushServiceSocket.CreateAccount(true);
         }
 
         /// <summary>
@@ -124,10 +127,10 @@ public void RequestVoiceVerificationCode()// throws IOException
         /// <param name="fetchesMessages">True if the client does not support GCM</param>
         /// <param name="pin"></param>
         /// <returns></returns>
-        public void VerifyAccountWithCode(string verificationCode, string signalingKey,
+        public async Task VerifyAccountWithCode(string verificationCode, string signalingKey,
                                    uint signalProtocolRegistrationId, bool fetchesMessages, string pin)
         {
-            this.PushServiceSocket.VerifyAccountCode(verificationCode, signalingKey,
+            await PushServiceSocket.VerifyAccountCode(verificationCode, signalingKey,
                                                  signalProtocolRegistrationId, fetchesMessages, pin);
         }
 
@@ -142,9 +145,9 @@ public void VerifyAccountWithCode(string verificationCode, string signalingKey,
         /// <param name="fetchesMessages">True if the client does not support GCM</param>
         /// <param name="pin"></param>
         /// <returns></returns>
-        public void SetAccountAttributes(string signalingKey, uint signalProtocolRegistrationId, bool fetchesMessages, string pin)
+        public async Task SetAccountAttributes(string signalingKey, uint signalProtocolRegistrationId, bool fetchesMessages, string pin)
         {
-            this.PushServiceSocket.SetAccountAttributes(signalingKey, signalProtocolRegistrationId, fetchesMessages, pin);
+            await PushServiceSocket.SetAccountAttributes(signalingKey, signalProtocolRegistrationId, fetchesMessages, pin);
         }
 
         /// <summary>
@@ -155,48 +158,48 @@ public void SetAccountAttributes(string signalingKey, uint signalProtocolRegistr
         /// <param name="signedPreKey">The client's signed prekey.</param>
         /// <param name="oneTimePreKeys">The client's list of one-time prekeys.</param>
         /// <returns></returns>
-        public bool SetPreKeys(IdentityKey identityKey, SignedPreKeyRecord signedPreKey, IList<PreKeyRecord> oneTimePreKeys)//throws IOException
+        public async Task<bool> SetPreKeys(IdentityKey identityKey, SignedPreKeyRecord signedPreKey, IList<PreKeyRecord> oneTimePreKeys)//throws IOException
         {
-            this.PushServiceSocket.RegisterPreKeys(identityKey, signedPreKey, oneTimePreKeys);
+            await PushServiceSocket.RegisterPreKeys(identityKey, signedPreKey, oneTimePreKeys);
             return true;
         }
 
         /// <summary>
         ///
         /// </summary>
         /// <returns>The server's count of currently available (eg. unused) prekeys for this user.</returns>
-        public int GetPreKeysCount()// throws IOException
+        public async Task<int> GetPreKeysCount()// throws IOException
         {
-            return this.PushServiceSocket.GetAvailablePreKeys();
+            return await PushServiceSocket.GetAvailablePreKeys();
         }
 
         /// <summary>
         /// Set the client's signed prekey.
         /// </summary>
         /// <param name="signedPreKey">The client's new signed prekey.</param>
-        public void SetSignedPreKey(SignedPreKeyRecord signedPreKey)// throws IOException
+        public async Task SetSignedPreKey(SignedPreKeyRecord signedPreKey)// throws IOException
         {
-            this.PushServiceSocket.SetCurrentSignedPreKey(signedPreKey);
+            await PushServiceSocket.SetCurrentSignedPreKey(signedPreKey);
         }
 
         /// <summary>
         ///
         /// </summary>
         /// <returns>The server's view of the client's current signed prekey.</returns>
-        public SignedPreKeyEntity GetSignedPreKey()// throws IOException
+        public async Task<SignedPreKeyEntity> GetSignedPreKey()// throws IOException
         {
-            return this.PushServiceSocket.GetCurrentSignedPreKey();
+            return await PushServiceSocket.GetCurrentSignedPreKey();
         }
 
         /// <summary>
         /// Checks whether a contact is currently registered with the server
         /// </summary>
         /// <param name="e164number">The contact to check.</param>
         /// <returns>An optional ContactTokenDetails, present if registered, absent if not.</returns>
-        public May<ContactTokenDetails> GetContact(string e164number)// throws IOException
+        public async Task<May<ContactTokenDetails>> GetContact(string e164number)// throws IOException
         {
             string contactToken = CreateDirectoryServerToken(e164number, true);
-            ContactTokenDetails contactTokenDetails = this.PushServiceSocket.GetContactTokenDetails(contactToken);
+            ContactTokenDetails contactTokenDetails = await PushServiceSocket.GetContactTokenDetails(contactToken);
 
             if (contactTokenDetails != null)
             {
@@ -211,10 +214,10 @@ public May<ContactTokenDetails> GetContact(string e164number)// throws IOExcepti
         /// </summary>
         /// <param name="e164numbers">The contacts to check.</param>
         /// <returns>A list of ContactTokenDetails for the registered users.</returns>
-        public List<ContactTokenDetails> GetContacts(IList<string> e164numbers)
+        public async Task<List<ContactTokenDetails>> GetContacts(IList<string> e164numbers)
         {
             IDictionary<string, string> contactTokensMap = CreateDirectoryServerTokenMap(e164numbers);
-            List<ContactTokenDetails> activeTokens = this.PushServiceSocket.RetrieveDirectory(contactTokensMap.Keys);
+            List<ContactTokenDetails> activeTokens = await PushServiceSocket.RetrieveDirectory(contactTokensMap.Keys);
 
             foreach (ContactTokenDetails activeToken in activeTokens)
             {
@@ -242,9 +245,9 @@ public async Task<string> GetNewDeviceUuid(CancellationToken token)
         /// Called by an already verified device.
         /// </summary>
         /// <returns>A verification code (String of 6 digits)</returns>
-        public string GetNewDeviceVerificationCode()// throws IOException
+        public async Task<string> GetNewDeviceVerificationCode()// throws IOException
         {
-            return this.PushServiceSocket.GetNewDeviceVerificationCode();
+            return await PushServiceSocket.GetNewDeviceVerificationCode();
         }
 
         /// <summary>
@@ -302,7 +305,7 @@ public async Task<int> FinishNewDeviceRegistration(CancellationToken token, Sign
         /// <param name="identityKeyPair"></param>
         /// <param name="profileKey"></param>
         /// <param name="code"></param>
-        public void AddDevice(string deviceIdentifier,
+        public async Task AddDevice(string deviceIdentifier,
                               ECPublicKey deviceKey,
                               IdentityKeyPair identityKeyPair,
                               byte[] profileKey,
@@ -323,25 +326,25 @@ public void AddDevice(string deviceIdentifier,
             }
 
             byte[] ciphertext = cipher.encrypt(message);
-            this.PushServiceSocket.SendProvisioningMessage(deviceIdentifier, ciphertext);
+            await PushServiceSocket.SendProvisioningMessage(deviceIdentifier, ciphertext);
         }
 
         /// <summary>
         /// TODO
         /// </summary>
         /// <returns></returns>
-        public List<DeviceInfo> GetDevices()
+        public async Task<List<DeviceInfo>> GetDevices()
         {
-            return this.PushServiceSocket.GetDevices();
+            return await PushServiceSocket.GetDevices();
         }
 
         /// <summary>
         /// TODO
         /// </summary>
         /// <param name="deviceId"></param>
-        public void RemoveDevice(long deviceId)
+        public async Task RemoveDevice(long deviceId)
         {
-            this.PushServiceSocket.RemoveDevice(deviceId);
+            await PushServiceSocket.RemoveDevice(deviceId);
         }
 
         /// <summary>
@@ -358,26 +361,26 @@ public async Task<TurnServerInfo> GetTurnServerInfo(CancellationToken token)
         /// </summary>
         /// <param name="key"></param>
         /// <param name="name"></param>
-        public void SetProfileName(byte[] key, string name)
+        public async Task SetProfileName(byte[] key, string name)
         {
             if (name == null) name = "";
             string ciphertextName = Base64.EncodeBytesWithoutPadding(new ProfileCipher(key).EncryptName(Encoding.Unicode.GetBytes(name), ProfileCipher.NAME_PADDED_LENGTH));
-            PushServiceSocket.SetProfileName(ciphertextName);
+            await PushServiceSocket.SetProfileName(ciphertextName);
         }
 
         /// <summary>
         /// TODO
         /// </summary>
         /// <param name="key"></param>
         /// <param name="avatar"></param>
-        public void SetProfileAvatar(byte[] key, StreamDetails avatar)
+        public async Task SetProfileAvatar(byte[] key, StreamDetails avatar)
         {
             ProfileAvatarData profileAvatarData = null;
             if (avatar != null)
             {
                 profileAvatarData = new ProfileAvatarData(avatar.InputStream, avatar.Length, avatar.ContentType, new ProfileCipherOutputStreamFactory(key));
             }
-            PushServiceSocket.SetProfileAvatar(profileAvatarData);
+            await PushServiceSocket.SetProfileAvatar(profileAvatarData);
         }
 
         /// <summary>

libsignal-service-dotnet/SignalServiceMessagePipe.cs

@@ -33,7 +33,16 @@ internal SignalServiceMessagePipe(CancellationToken token, SignalWebSocketConnec
             this.Token = token;
             this.Websocket = websocket;
             this.CredentialsProvider = credentialsProvider;
-            this.Websocket.Connect(token).Wait();
+        }
+
+        /// <summary>
+        /// Connect message pipe.
+        /// </summary>
+        /// <returns>Task</returns>
+        public async Task Connect()
+        {
+            Logger.LogTrace("Connecting to message pipe");
+            await Websocket.Connect(Token);
         }
 
         /// <summary>
@@ -79,7 +88,7 @@ public async Task ReadBlocking(IMessagePipeCallback callback)
         /// </summary>
         /// <param name="list"></param>
         /// <returns></returns>
-        public SendMessageResponse Send(OutgoingPushMessageList list)
+        public async Task<SendMessageResponse> Send(OutgoingPushMessageList list)
         {
             Logger.LogTrace("Send()");
             WebSocketRequestMessage requestmessage = new WebSocketRequestMessage()
@@ -92,7 +101,7 @@ public SendMessageResponse Send(OutgoingPushMessageList list)
             requestmessage.Headers.Add("content-type:application/json");
             Logger.LogDebug("Sending message {0}", requestmessage.Id);
             var t = Websocket.SendRequest(requestmessage);
-            t.Wait();
+            await t;
             if (t.IsCompleted)
             {
                 var response = t.Result;
@@ -115,7 +124,7 @@ public SendMessageResponse Send(OutgoingPushMessageList list)
         /// </summary>
         /// <param name="address"></param>
         /// <returns></returns>
-        public SignalServiceProfile GetProfile(SignalServiceAddress address)
+        public async Task<SignalServiceProfile> GetProfile(SignalServiceAddress address)
         {
             Logger.LogTrace("GetProfile()");
             WebSocketRequestMessage requestMessage = new WebSocketRequestMessage()
@@ -126,7 +135,7 @@ public SignalServiceProfile GetProfile(SignalServiceAddress address)
             };
 
             var t = Websocket.SendRequest(requestMessage);
-            t.Wait();
+            await t;
             if (t.IsCompleted)
             {
                 var response = t.Result;

libsignal-service-dotnet/SignalServiceMessageReceiver.cs

@@ -60,9 +60,9 @@ public SignalServiceMessageReceiver(CancellationToken token, SignalServiceConfig
         /// </summary>
         /// <param name="address"></param>
         /// <returns></returns>
-        public SignalServiceProfile RetrieveProfile(SignalServiceAddress address)
+        public async Task<SignalServiceProfile> RetrieveProfile(SignalServiceAddress address)
         {
-            return Socket.RetrieveProfile(address);
+            return await Socket.RetrieveProfile(address);
         }
 
         /// <summary>
@@ -88,9 +88,9 @@ public Stream RetrieveProfileAvatar(string path, FileStream destination, byte[]
         /// <param name="tmpCipherDestination">The temporary destination for this attachment before decryption</param>
         /// <param name="maxSizeBytes">The maximum size for this attachment (not yet implemented)</param>
         /// <param name="listener">An optional listener (may be null) to receive callbacks on download progress.</param>
-        public Stream RetrieveAttachment(SignalServiceAttachmentPointer pointer, Stream tmpCipherDestination, int maxSizeBytes, IProgressListener listener)
+        public async Task<Stream> RetrieveAttachment(SignalServiceAttachmentPointer pointer, Stream tmpCipherDestination, int maxSizeBytes, IProgressListener listener)
         {
-            Socket.RetrieveAttachment(pointer.Relay, pointer.Id, tmpCipherDestination, maxSizeBytes);
+            await Socket.RetrieveAttachment(pointer.Relay, pointer.Id, tmpCipherDestination, maxSizeBytes);
             tmpCipherDestination.Position = 0;
             return AttachmentCipherInputStream.CreateFor(tmpCipherDestination, pointer.Size != null ? pointer.Size.Value : 0, pointer.Key, pointer.Digest);
         }
@@ -100,9 +100,9 @@ public Stream RetrieveAttachment(SignalServiceAttachmentPointer pointer, Stream
         /// </summary>
         /// <param name="pointer">The pointer to the attachment</param>
         /// <returns></returns>
-        public string RetrieveAttachmentDownloadUrl(SignalServiceAttachmentPointer pointer)
+        public async Task<string> RetrieveAttachmentDownloadUrl(SignalServiceAttachmentPointer pointer)
         {
-            return Socket.RetrieveAttachmentDownloadUrl(pointer.Relay, pointer.Id);
+            return await Socket.RetrieveAttachmentDownloadUrl(pointer.Relay, pointer.Id);
         }
 
         /// <summary>
@@ -111,16 +111,18 @@ public string RetrieveAttachmentDownloadUrl(SignalServiceAttachmentPointer point
         /// Callers must call <see cref="SignalServiceMessagePipe.Shutdown()"/> when finished with the pipe.
         /// </summary>
         /// <returns>A SignalServiceMessagePipe for receiving Signal Service messages.</returns>
-        public SignalServiceMessagePipe CreateMessagePipe()
+        public async Task<SignalServiceMessagePipe> CreateMessagePipe()
         {
             SignalWebSocketConnection webSocket = new SignalWebSocketConnection(Token, Urls.SignalServiceUrls[0].Url, CredentialsProvider, UserAgent, ConnectivityListener);
-            return new SignalServiceMessagePipe(Token, webSocket, CredentialsProvider);
+            var messagePipe = new SignalServiceMessagePipe(Token, webSocket, CredentialsProvider);
+            await messagePipe.Connect();
+            return messagePipe;
         }
 
         public async Task<List<SignalServiceEnvelope>> RetrieveMessages(IMessagePipeCallback callback)
         {
             List<SignalServiceEnvelope> results = new List<SignalServiceEnvelope>();
-            List<SignalServiceEnvelopeEntity> entities = Socket.GetMessages();
+            List<SignalServiceEnvelopeEntity> entities = await Socket.GetMessages();
 
             foreach (SignalServiceEnvelopeEntity entity in entities)
             {
@@ -132,7 +134,7 @@ public async Task<List<SignalServiceEnvelope>> RetrieveMessages(IMessagePipeCall
                 await callback.OnMessage(envelope);
                 results.Add(envelope);
 
-                Socket.AcknowledgeMessage(entity.Source, entity.Timestamp);
+                await Socket.AcknowledgeMessage(entity.Source, entity.Timestamp);
             }
             return results;
         }