Merge pull request #1669 from session-foundation/fix-download-avatar-track-reupload-neede

fix: track reupload needed for incoming avatar for us

Author: Bilb

ts/session/apis/seed_node_api/SeedNodeAPI.ts

@@ -208,23 +208,21 @@ export async function TEST_fetchSnodePoolFromSeedNodeRetryable(
     throw new Error('fetchSnodePoolFromSeedNodeRetryable: Seed nodes are empty');
   }
 
-  const seedNodeUrl = _.sample(seedNodes);
-  if (!seedNodeUrl) {
+  if (!seedNodes.length) {
     window?.log?.warn(
-      'loki_snode_api::fetchSnodePoolFromSeedNodeRetryable - Could not select random snodes from',
+      'loki_snode_api::fetchSnodePoolFromSeedNodeRetryable - no seednodes',
       seedNodes
     );
     throw new Error('fetchSnodePoolFromSeedNodeRetryable: Seed nodes are empty #2');
   }
 
-  const tryUrl = new URL(seedNodeUrl);
+  const snodes = await Promise.race(seedNodes.map(s => getSnodesFromSeedUrl(new URL(s))));
 
-  const snodes = await getSnodesFromSeedUrl(tryUrl);
   if (snodes.length === 0) {
     window?.log?.warn(
-      `loki_snode_api::fetchSnodePoolFromSeedNodeRetryable - ${seedNodeUrl} did not return any snodes`
+      `loki_snode_api::fetchSnodePoolFromSeedNodeRetryable - Promise.race did not return any snodes`
     );
-    throw new Error(`Failed to contact seed node: ${seedNodeUrl}`);
+    throw new Error(`Failed to contact seed node: Promise.race did not return any snodes`);
   }
 
   return snodes;

ts/session/utils/job_runners/jobs/AvatarDownloadJob.ts

@@ -164,7 +164,7 @@ class AvatarDownloadJob extends PersistedJob<AvatarDownloadPersistedData> {
           );
 
           // we autoscale incoming avatars because our app keeps decrypted avatars in memory and some platforms allows large avatars to be uploaded.
-          const processed = await processAvatarData(decryptedData, conversation.isMe());
+          const processed = await processAvatarData(decryptedData, conversation.isMe(), true);
 
           const upgradedMainAvatar = await processNewAttachment({
             data: processed.mainAvatarDetails.outputBuffer,

ts/session/utils/job_runners/jobs/AvatarMigrateJob.ts

@@ -141,7 +141,7 @@ class AvatarMigrateJob extends PersistedJob<AvatarMigratePersistedData> {
       }
 
       // we autoscale incoming avatars because our app keeps decrypted avatars in memory and some platforms allows large avatars to be uploaded.
-      const processed = await processAvatarData(decryptedData, conversation.isMe());
+      const processed = await processAvatarData(decryptedData, conversation.isMe(), true);
 
       const upgradedMainAvatar = await processNewAttachment({
         data: processed.mainAvatarDetails.outputBuffer,

ts/util/avatar/processAvatarData.ts

@@ -16,7 +16,11 @@ import { MAX_ATTACHMENT_FILESIZE_BYTES } from '../../session/constants';
  * This is because we need to be able to reupload our full avatar to the file server, and mobile pixel density can be 3x.
  * We still want to reduce incoming avatars to 200 x 200 for performance reasons.
  */
-export async function processAvatarData(arrayBuffer: ArrayBuffer, planForReupload: boolean) {
+export async function processAvatarData(
+  arrayBuffer: ArrayBuffer,
+  planForReupload: boolean,
+  remoteChange = false
+) {
   if (!arrayBuffer || arrayBuffer.byteLength === 0 || !isArrayBuffer(arrayBuffer)) {
     throw new Error('processAvatarData: arrayBuffer is empty');
   }
@@ -27,7 +31,11 @@ export async function processAvatarData(arrayBuffer: ArrayBuffer, planForReuploa
    * 2. a fallback avatar in case the user looses its pro (static image, even if the main avatar is animated)
    */
   // this is step 1, we generate a scaled down avatar, but keep its nature (animated or not)
-  const processed = await ImageProcessor.processAvatarData(arrayBuffer, planForReupload);
+  const processed = await ImageProcessor.processAvatarData(
+    arrayBuffer,
+    planForReupload,
+    remoteChange
+  );
 
   if (!processed) {
     throw new Error('processLocalAvatarChange: failed to process avatar');

ts/webworker/workers/node/image_processor/image_processor.d.ts

@@ -61,7 +61,8 @@ export type ImageProcessorWorkerActions = {
    */
   processAvatarData: (
     input: ArrayBufferLike,
-    planForReupload: boolean
+    planForReupload: boolean,
+    remoteChange: boolean
   ) => Promise<{
     mainAvatarDetails: Omit<MaybeAnimatedOutputType, 'format'> & WithImageFormat<'gif' | 'webp'>;
     avatarFallback: (StaticOutputType & WithWebpFormat) | null;

ts/webworker/workers/node/image_processor/image_processor.worker.ts

@@ -264,15 +264,32 @@ async function sleepFor(ms: number) {
   });
 }
 
-async function processPlanForReuploadAvatar({ inputBuffer }: { inputBuffer: ArrayBufferLike }) {
+async function processPlanForReuploadAvatar({
+  inputBuffer,
+  remoteChange,
+}: {
+  inputBuffer: ArrayBufferLike;
+  remoteChange: boolean;
+}) {
   const start = Date.now();
 
   const metadata = await metadataFromBuffer(inputBuffer, true, { animated: true });
   if (!metadata) {
     return null;
   }
 
-  const sizeRequired = maxAvatarDetails.maxSidePlanReupload;
+  /**
+   * This is not pretty, but when we download our own avatar from the network and we didn't set it locally,
+   * we need to make sure a reupload will be planned if required.
+   * What this means is that, if we get an avatar of size 640 from the network we should plan for a reupload.
+   * But, if we resize it here to 600, the AvatarReuploadJob will be skipped as the avatar is already the correct size.
+   * As a hack, we add 1 pixel to the size required when this is a remote change, so that the AvatarReuploadJob will be triggered.
+   *
+   * Note: We do not upscale the file if it's already smaller than 600px, so a reupload won't be triggered if a device set an avatar to 600 already.
+   */
+  const sizeRequired = remoteChange
+    ? maxAvatarDetails.maxSidePlanReupload + 1
+    : maxAvatarDetails.maxSidePlanReupload;
   const avatarIsAnimated = isAnimated(metadata);
 
   if (avatarIsAnimated && metadata.format !== 'webp' && metadata.format !== 'gif') {
@@ -523,13 +540,17 @@ const workerActions: ImageProcessorWorkerActions = {
     };
   },
 
-  processAvatarData: async (inputBuffer: ArrayBufferLike, planForReupload: boolean) => {
+  processAvatarData: async (
+    inputBuffer: ArrayBufferLike,
+    planForReupload: boolean,
+    remoteChange: boolean
+  ) => {
     if (!inputBuffer?.byteLength) {
       throw new Error('processAvatarData: inputBuffer is required');
     }
 
     if (planForReupload) {
-      return await processPlanForReuploadAvatar({ inputBuffer });
+      return await processPlanForReuploadAvatar({ inputBuffer, remoteChange });
     }
     return await processNoPlanForReuploadAvatar({ inputBuffer });
   },