1package eu.siacs.conversations.xmpp.manager;
2
3import android.graphics.Bitmap;
4import android.net.Uri;
5import android.util.Log;
6import androidx.annotation.NonNull;
7import androidx.heifwriter.AvifWriter;
8import androidx.heifwriter.HeifWriter;
9import com.google.common.base.Preconditions;
10import com.google.common.collect.Collections2;
11import com.google.common.collect.ComparisonChain;
12import com.google.common.collect.ImmutableList;
13import com.google.common.collect.Iterables;
14import com.google.common.collect.Ordering;
15import com.google.common.hash.Hashing;
16import com.google.common.hash.HashingOutputStream;
17import com.google.common.io.ByteStreams;
18import com.google.common.io.Files;
19import com.google.common.util.concurrent.FutureCallback;
20import com.google.common.util.concurrent.Futures;
21import com.google.common.util.concurrent.ListenableFuture;
22import com.google.common.util.concurrent.MoreExecutors;
23import com.google.common.util.concurrent.SettableFuture;
24import eu.siacs.conversations.AppSettings;
25import eu.siacs.conversations.Config;
26import eu.siacs.conversations.entities.Contact;
27import eu.siacs.conversations.entities.Conversation;
28import eu.siacs.conversations.entities.Conversational;
29import eu.siacs.conversations.persistance.FileBackend;
30import eu.siacs.conversations.services.XmppConnectionService;
31import eu.siacs.conversations.utils.Compatibility;
32import eu.siacs.conversations.utils.PhoneHelper;
33import eu.siacs.conversations.xml.Namespace;
34import eu.siacs.conversations.xmpp.Jid;
35import eu.siacs.conversations.xmpp.XmppConnection;
36import im.conversations.android.xmpp.NodeConfiguration;
37import im.conversations.android.xmpp.model.ByteContent;
38import im.conversations.android.xmpp.model.avatar.Data;
39import im.conversations.android.xmpp.model.avatar.Info;
40import im.conversations.android.xmpp.model.avatar.Metadata;
41import im.conversations.android.xmpp.model.pubsub.Items;
42import im.conversations.android.xmpp.model.upload.purpose.Profile;
43import im.conversations.android.xmpp.model.vcard.update.VCardUpdate;
44import java.io.File;
45import java.io.FileOutputStream;
46import java.io.IOException;
47import java.util.Collection;
48import java.util.List;
49import java.util.Map;
50import java.util.NoSuchElementException;
51import java.util.Objects;
52import java.util.UUID;
53import java.util.concurrent.Executor;
54import java.util.concurrent.Executors;
55import okhttp3.Call;
56import okhttp3.Callback;
57import okhttp3.HttpUrl;
58import okhttp3.OkHttpClient;
59import okhttp3.Request;
60import okhttp3.Response;
61
62public class AvatarManager extends AbstractManager {
63
64 private static final Object RENAME_LOCK = new Object();
65
66 private static final List<String> SUPPORTED_CONTENT_TYPES;
67
68 private static final Ordering<Info> AVATAR_ORDERING =
69 new Ordering<>() {
70 @Override
71 public int compare(Info left, Info right) {
72 return ComparisonChain.start()
73 .compare(
74 right.getWidth() * right.getHeight(),
75 left.getWidth() * left.getHeight())
76 .compare(
77 ImageFormat.formatPriority(right.getType()),
78 ImageFormat.formatPriority(left.getType()))
79 .result();
80 }
81 };
82
83 static {
84 final ImmutableList.Builder<ImageFormat> builder = new ImmutableList.Builder<>();
85 builder.add(ImageFormat.JPEG, ImageFormat.PNG, ImageFormat.WEBP);
86 if (Compatibility.twentyEight()) {
87 builder.add(ImageFormat.HEIF);
88 }
89 if (Compatibility.thirtyFour()) {
90 builder.add(ImageFormat.AVIF);
91 }
92 final var supportedFormats = builder.build();
93 SUPPORTED_CONTENT_TYPES =
94 ImmutableList.copyOf(
95 Collections2.transform(supportedFormats, ImageFormat::toContentType));
96 }
97
98 private static final Executor AVATAR_COMPRESSION_EXECUTOR =
99 MoreExecutors.newSequentialExecutor(Executors.newSingleThreadScheduledExecutor());
100
101 private final XmppConnectionService service;
102
103 public AvatarManager(final XmppConnectionService service, XmppConnection connection) {
104 super(service.getApplicationContext(), connection);
105 this.service = service;
106 }
107
108 private ListenableFuture<byte[]> fetch(final Jid address, final String itemId) {
109 final var future = getManager(PubSubManager.class).fetchItem(address, itemId, Data.class);
110 return Futures.transform(future, ByteContent::asBytes, MoreExecutors.directExecutor());
111 }
112
113 private ListenableFuture<Info> fetchAndStoreWithFallback(
114 final Jid address, final Info picked, final Info fallback) {
115 Preconditions.checkArgument(fallback.getUrl() == null, "fallback avatar must be in-band");
116 final var url = picked.getUrl();
117 if (url != null) {
118 final var httpDownloadFuture = fetchAndStoreHttp(url, picked);
119 return Futures.catchingAsync(
120 httpDownloadFuture,
121 Exception.class,
122 ex -> {
123 Log.d(
124 Config.LOGTAG,
125 getAccount().getJid().asBareJid()
126 + ": could not download avatar for "
127 + address
128 + " from "
129 + url,
130 ex);
131 return fetchAndStoreInBand(address, fallback);
132 },
133 MoreExecutors.directExecutor());
134 } else {
135 return fetchAndStoreInBand(address, picked);
136 }
137 }
138
139 private ListenableFuture<Info> fetchAndStoreInBand(final Jid address, final Info avatar) {
140 final var future = fetch(address, avatar.getId());
141 return Futures.transformAsync(
142 future,
143 data -> {
144 final var actualHash = Hashing.sha1().hashBytes(data).toString();
145 if (!actualHash.equals(avatar.getId())) {
146 throw new IllegalStateException(
147 String.format("In-band avatar hash of %s did not match", address));
148 }
149
150 final var file = FileBackend.getAvatarFile(context, avatar.getId());
151 if (file.exists()) {
152 return Futures.immediateFuture(avatar);
153 }
154 return Futures.transform(
155 write(file, data), v -> avatar, MoreExecutors.directExecutor());
156 },
157 MoreExecutors.directExecutor());
158 }
159
160 private ListenableFuture<Void> write(final File destination, byte[] bytes) {
161 return Futures.submit(
162 () -> {
163 final var randomFile =
164 new File(context.getCacheDir(), UUID.randomUUID().toString());
165 Files.write(bytes, randomFile);
166 if (moveAvatarIntoCache(randomFile, destination)) {
167 return null;
168 }
169 throw new IllegalStateException(
170 String.format(
171 "Could not move file to %s", destination.getAbsolutePath()));
172 },
173 AVATAR_COMPRESSION_EXECUTOR);
174 }
175
176 private ListenableFuture<Info> fetchAndStoreHttp(final HttpUrl url, final Info avatar) {
177 final SettableFuture<Info> settableFuture = SettableFuture.create();
178 final OkHttpClient client =
179 service.getHttpConnectionManager().buildHttpClient(url, getAccount(), 30, false);
180 final var request = new Request.Builder().url(url).get().build();
181 client.newCall(request)
182 .enqueue(
183 new Callback() {
184 @Override
185 public void onFailure(@NonNull Call call, @NonNull IOException e) {
186 settableFuture.setException(e);
187 }
188
189 @Override
190 public void onResponse(@NonNull Call call, @NonNull Response response) {
191 if (response.isSuccessful()) {
192 try {
193 write(avatar, response);
194 } catch (final Exception e) {
195 settableFuture.setException(e);
196 return;
197 }
198 settableFuture.set(avatar);
199 } else {
200 settableFuture.setException(
201 new IOException("HTTP call was not successful"));
202 }
203 }
204 });
205 return settableFuture;
206 }
207
208 private void write(final Info avatar, Response response) throws IOException {
209 final var body = response.body();
210 if (body == null) {
211 throw new IOException("Body was null");
212 }
213 final long bytes = avatar.getBytes();
214 final long actualBytes;
215 final var inputStream = ByteStreams.limit(body.byteStream(), avatar.getBytes());
216 final var randomFile = new File(context.getCacheDir(), UUID.randomUUID().toString());
217 final String actualHash;
218 try (final var fileOutputStream = new FileOutputStream(randomFile);
219 var hashingOutputStream =
220 new HashingOutputStream(Hashing.sha1(), fileOutputStream)) {
221 actualBytes = ByteStreams.copy(inputStream, hashingOutputStream);
222 actualHash = hashingOutputStream.hash().toString();
223 }
224 if (actualBytes != bytes) {
225 throw new IllegalStateException("File size did not meet expected size");
226 }
227 if (!actualHash.equals(avatar.getId())) {
228 throw new IllegalStateException("File hash did not match");
229 }
230 final var avatarFile = FileBackend.getAvatarFile(context, avatar.getId());
231 if (moveAvatarIntoCache(randomFile, avatarFile)) {
232 return;
233 }
234 throw new IOException("Could not move avatar to avatar location");
235 }
236
237 private void setAvatar(final Jid address, final Info info) {
238 setAvatar(address, info.getId());
239 }
240
241 private void setAvatar(final Jid from, final String id) {
242 Log.d(Config.LOGTAG, "setting avatar for " + from + " to " + id);
243 if (from.isBareJid()) {
244 setAvatarContact(from, id);
245 } else {
246 setAvatarMucUser(from, id);
247 }
248 }
249
250 private void setAvatarContact(final Jid from, final String id) {
251 final var account = getAccount();
252 if (account.getJid().asBareJid().equals(from)) {
253 if (account.setAvatar(id)) {
254 getDatabase().updateAccount(account);
255 service.notifyAccountAvatarHasChanged(account);
256 }
257 service.getAvatarService().clear(account);
258 service.updateConversationUi();
259 service.updateAccountUi();
260 } else {
261 final Contact contact = account.getRoster().getContact(from);
262 if (contact.setAvatar(id)) {
263 connection.getManager(RosterManager.class).writeToDatabaseAsync();
264 service.getAvatarService().clear(contact);
265
266 final var conversation = service.find(account, from);
267 if (conversation != null && conversation.getMode() == Conversational.MODE_MULTI) {
268 service.getAvatarService().clear(conversation.getMucOptions());
269 }
270
271 service.updateConversationUi();
272 service.updateRosterUi();
273 }
274 }
275 }
276
277 private void setAvatarMucUser(final Jid from, final String id) {
278 final var account = getAccount();
279 final Conversation conversation = service.find(account, from.asBareJid());
280 if (conversation == null || conversation.getMode() != Conversation.MODE_MULTI) {
281 return;
282 }
283 final var user = conversation.getMucOptions().findUserByFullJid(from);
284 if (user == null) {
285 return;
286 }
287 if (user.setAvatar(id)) {
288 service.getAvatarService().clear(user);
289 service.updateConversationUi();
290 service.updateMucRosterUi();
291 }
292 }
293
294 public void handleItems(final Jid from, final Items items) {
295 final var account = getAccount();
296 // TODO support retract
297 final var entry = items.getFirstItemWithId(Metadata.class);
298 if (entry == null) {
299 return;
300 }
301 final var avatar = getPreferredFallback(entry);
302 if (avatar == null) {
303 return;
304 }
305
306 Log.d(Config.LOGTAG, "picked avatar from " + from + ": " + avatar.preferred);
307
308 final var cache = FileBackend.getAvatarFile(context, avatar.preferred.getId());
309
310 if (cache.exists()) {
311 setAvatar(from, avatar.preferred);
312 } else if (service.isDataSaverDisabled()) {
313 final var future =
314 this.fetchAndStoreWithFallback(from, avatar.preferred, avatar.fallback);
315 Futures.addCallback(
316 future,
317 new FutureCallback<Info>() {
318 @Override
319 public void onSuccess(Info result) {
320 setAvatar(from, result);
321 Log.d(
322 Config.LOGTAG,
323 account.getJid().asBareJid()
324 + ": successfully fetched pep avatar for "
325 + from);
326 }
327
328 @Override
329 public void onFailure(@NonNull Throwable t) {
330 Log.d(Config.LOGTAG, "could not fetch avatar", t);
331 }
332 },
333 MoreExecutors.directExecutor());
334 }
335 }
336
337 public void handleVCardUpdate(final Jid address, final VCardUpdate vCardUpdate) {
338 final var hash = vCardUpdate.getHash();
339 if (hash == null) {
340 return;
341 }
342 handleVCardUpdate(address, hash);
343 }
344
345 public void handleVCardUpdate(final Jid address, final String hash) {
346 Preconditions.checkArgument(VCardUpdate.isValidSHA1(hash));
347 final var avatarFile = FileBackend.getAvatarFile(context, hash);
348 if (avatarFile.exists()) {
349 setAvatar(address, hash);
350 } else if (service.isDataSaverDisabled()) {
351 final var future = this.fetchAndStoreVCard(address, hash);
352 Futures.addCallback(
353 future,
354 new FutureCallback<Void>() {
355 @Override
356 public void onSuccess(Void result) {
357 Log.d(Config.LOGTAG, "successfully fetch vCard avatar for " + address);
358 }
359
360 @Override
361 public void onFailure(@NonNull Throwable t) {
362 Log.d(Config.LOGTAG, "could not fetch avatar for " + address, t);
363 }
364 },
365 MoreExecutors.directExecutor());
366 }
367 }
368
369 private PreferredFallback getPreferredFallback(final Map.Entry<String, Metadata> entry) {
370 final var mainItemId = entry.getKey();
371 final var infos = entry.getValue().getInfos();
372
373 final var inBandAvatar = Iterables.find(infos, i -> mainItemId.equals(i.getId()), null);
374
375 if (inBandAvatar == null || inBandAvatar.getUrl() != null) {
376 return null;
377 }
378
379 final var optionalAutoAcceptSize = new AppSettings(context).getAutoAcceptFileSize();
380 if (optionalAutoAcceptSize.isEmpty()) {
381 return new PreferredFallback(inBandAvatar);
382 } else {
383
384 final var supported =
385 Collections2.filter(
386 infos,
387 i ->
388 Objects.nonNull(i.getId())
389 && i.getBytes() > 0
390 && i.getHeight() > 0
391 && i.getWidth() > 0
392 && SUPPORTED_CONTENT_TYPES.contains(i.getType()));
393
394 final var autoAcceptSize = optionalAutoAcceptSize.get();
395
396 final var supportedBelowLimit =
397 Collections2.filter(supported, i -> i.getBytes() <= autoAcceptSize);
398
399 if (supportedBelowLimit.isEmpty()) {
400 return new PreferredFallback(inBandAvatar);
401 } else {
402 final var preferred =
403 Iterables.getFirst(AVATAR_ORDERING.sortedCopy(supportedBelowLimit), null);
404 return new PreferredFallback(preferred, inBandAvatar);
405 }
406 }
407 }
408
409 public void handleDelete(final Jid from) {
410 final var account = getAccount();
411 final boolean isAccount = account.getJid().asBareJid().equals(from);
412 if (isAccount) {
413 account.setAvatar(null);
414 getDatabase().updateAccount(account);
415 service.getAvatarService().clear(account);
416 Log.d(Config.LOGTAG, account.getJid().asBareJid() + ": deleted avatar metadata node");
417 }
418 }
419
420 private Info resizeAndStoreAvatar(
421 final Uri image, final int size, final ImageFormat format, final Integer charLimit)
422 throws Exception {
423 final var centerSquare = FileBackend.cropCenterSquare(context, image, size);
424 if (charLimit == null || format == ImageFormat.PNG) {
425 return resizeAndStoreAvatar(centerSquare, format, 90);
426 } else {
427 Info avatar = null;
428 for (int quality = 90; quality >= 50; quality = quality - 2) {
429 if (avatar != null) {
430 FileBackend.getAvatarFile(context, avatar.getId()).delete();
431 }
432 Log.d(Config.LOGTAG, "trying to save thumbnail with quality " + quality);
433 avatar = resizeAndStoreAvatar(centerSquare, format, quality);
434 if (avatar.getBytes() <= charLimit) {
435 return avatar;
436 }
437 }
438 return avatar;
439 }
440 }
441
442 private Info resizeAndStoreAvatar(final Bitmap image, ImageFormat format, final int quality)
443 throws Exception {
444 return switch (format) {
445 case PNG -> resizeAndStoreAvatar(image, Bitmap.CompressFormat.PNG, quality);
446 case JPEG -> resizeAndStoreAvatar(image, Bitmap.CompressFormat.JPEG, quality);
447 case WEBP -> resizeAndStoreAvatar(image, Bitmap.CompressFormat.WEBP, quality);
448 case HEIF -> resizeAndStoreAvatarAsHeif(image, quality);
449 case AVIF -> resizeAndStoreAvatarAsAvif(image, quality);
450 };
451 }
452
453 private Info resizeAndStoreAvatar(
454 final Bitmap image, final Bitmap.CompressFormat format, final int quality)
455 throws IOException {
456 final var randomFile = new File(context.getCacheDir(), UUID.randomUUID().toString());
457 final var fileOutputStream = new FileOutputStream(randomFile);
458 final var hashingOutputStream = new HashingOutputStream(Hashing.sha1(), fileOutputStream);
459 image.compress(format, quality, hashingOutputStream);
460 hashingOutputStream.close();
461 final var sha1 = hashingOutputStream.hash().toString();
462 final var avatarFile = FileBackend.getAvatarFile(context, sha1);
463 if (moveAvatarIntoCache(randomFile, avatarFile)) {
464 return new Info(
465 sha1,
466 avatarFile.length(),
467 ImageFormat.of(format).toContentType(),
468 image.getHeight(),
469 image.getWidth());
470 }
471 throw new IllegalStateException(
472 String.format("Could not move file to %s", avatarFile.getAbsolutePath()));
473 }
474
475 private Info resizeAndStoreAvatarAsHeif(final Bitmap image, final int quality)
476 throws Exception {
477 final var randomFile = new File(context.getCacheDir(), UUID.randomUUID().toString());
478 try (final var fileOutputStream = new FileOutputStream(randomFile);
479 final var heifWriter =
480 new HeifWriter.Builder(
481 fileOutputStream.getFD(),
482 image.getWidth(),
483 image.getHeight(),
484 HeifWriter.INPUT_MODE_BITMAP)
485 .setMaxImages(1)
486 .setQuality(quality)
487 .build()) {
488
489 heifWriter.start();
490 heifWriter.addBitmap(image);
491 heifWriter.stop(3_000);
492 }
493 return storeAsAvatar(randomFile, ImageFormat.HEIF, image.getHeight(), image.getWidth());
494 }
495
496 private Info resizeAndStoreAvatarAsAvif(final Bitmap image, final int quality)
497 throws Exception {
498 final var randomFile = new File(context.getCacheDir(), UUID.randomUUID().toString());
499 try (final var fileOutputStream = new FileOutputStream(randomFile);
500 final var avifWriter =
501 new AvifWriter.Builder(
502 fileOutputStream.getFD(),
503 image.getWidth(),
504 image.getHeight(),
505 AvifWriter.INPUT_MODE_BITMAP)
506 .setMaxImages(1)
507 .setQuality(quality)
508 .build()) {
509 avifWriter.start();
510 avifWriter.addBitmap(image);
511 avifWriter.stop(3_000);
512 }
513 return storeAsAvatar(randomFile, ImageFormat.AVIF, image.getHeight(), image.getWidth());
514 }
515
516 private Info storeAsAvatar(
517 final File randomFile, final ImageFormat type, final int height, final int width)
518 throws IOException {
519 final var sha1 = Files.asByteSource(randomFile).hash(Hashing.sha1()).toString();
520 final var avatarFile = FileBackend.getAvatarFile(context, sha1);
521 if (moveAvatarIntoCache(randomFile, avatarFile)) {
522 return new Info(sha1, avatarFile.length(), type.toContentType(), height, width);
523 }
524 throw new IllegalStateException(
525 String.format("Could not move file to %s", avatarFile.getAbsolutePath()));
526 }
527
528 public ListenableFuture<List<Info>> uploadAvatar(final Uri image, final int size) {
529 final var avatarFutures = new ImmutableList.Builder<ListenableFuture<Info>>();
530 final var avatarFuture = resizeAndStoreAvatarAsync(image, size, ImageFormat.JPEG);
531 final var avatarWithUrlFuture =
532 Futures.transformAsync(avatarFuture, this::upload, MoreExecutors.directExecutor());
533 avatarFutures.add(avatarWithUrlFuture);
534
535 if (Compatibility.twentyEight() && !PhoneHelper.isEmulator()) {
536 final var avatarHeifFuture = resizeAndStoreAvatarAsync(image, size, ImageFormat.HEIF);
537 final var avatarHeifWithUrlFuture =
538 Futures.transformAsync(
539 avatarHeifFuture, this::upload, MoreExecutors.directExecutor());
540 avatarFutures.add(avatarHeifWithUrlFuture);
541 }
542 if (Compatibility.thirtyFour() && !PhoneHelper.isEmulator()) {
543 final var avatarAvifFuture = resizeAndStoreAvatarAsync(image, size, ImageFormat.AVIF);
544 final var avatarAvifWithUrlFuture =
545 Futures.transformAsync(
546 avatarAvifFuture, this::upload, MoreExecutors.directExecutor());
547 avatarFutures.add(avatarAvifWithUrlFuture);
548 }
549
550 final var avatarThumbnailFuture =
551 resizeAndStoreAvatarAsync(
552 image, Config.AVATAR_SIZE, ImageFormat.JPEG, Config.AVATAR_CHAR_LIMIT);
553 avatarFutures.add(avatarThumbnailFuture);
554
555 return Futures.allAsList(avatarFutures.build());
556 }
557
558 private ListenableFuture<Info> upload(final Info avatar) {
559 final var file = FileBackend.getAvatarFile(context, avatar.getId());
560 final var urlFuture =
561 getManager(HttpUploadManager.class).upload(file, avatar.getType(), new Profile());
562 return Futures.transform(
563 urlFuture,
564 url -> {
565 avatar.setUrl(url);
566 return avatar;
567 },
568 MoreExecutors.directExecutor());
569 }
570
571 private ListenableFuture<Info> resizeAndStoreAvatarAsync(
572 final Uri image, final int size, final ImageFormat format) {
573 return resizeAndStoreAvatarAsync(image, size, format, null);
574 }
575
576 private ListenableFuture<Info> resizeAndStoreAvatarAsync(
577 final Uri image, final int size, final ImageFormat format, final Integer charLimit) {
578 return Futures.submit(
579 () -> resizeAndStoreAvatar(image, size, format, charLimit),
580 AVATAR_COMPRESSION_EXECUTOR);
581 }
582
583 public ListenableFuture<Void> publish(final Collection<Info> avatars, final boolean open) {
584 final Info mainAvatarInfo;
585 final byte[] mainAvatar;
586 try {
587 mainAvatarInfo = Iterables.find(avatars, a -> Objects.isNull(a.getUrl()));
588 mainAvatar =
589 Files.asByteSource(FileBackend.getAvatarFile(context, mainAvatarInfo.getId()))
590 .read();
591 } catch (final IOException | NoSuchElementException e) {
592 return Futures.immediateFailedFuture(e);
593 }
594 final NodeConfiguration configuration =
595 open ? NodeConfiguration.OPEN : NodeConfiguration.PRESENCE;
596 final var avatarData = new Data();
597 avatarData.setContent(mainAvatar);
598 final var future =
599 getManager(PepManager.class)
600 .publish(avatarData, mainAvatarInfo.getId(), configuration);
601 return Futures.transformAsync(
602 future,
603 v -> {
604 final var id = mainAvatarInfo.getId();
605 final var metadata = new Metadata();
606 metadata.addExtensions(avatars);
607 return getManager(PepManager.class).publish(metadata, id, configuration);
608 },
609 MoreExecutors.directExecutor());
610 }
611
612 public ListenableFuture<Void> uploadAndPublish(final Uri image, final boolean open) {
613 final var infoFuture =
614 connection
615 .getManager(AvatarManager.class)
616 .uploadAvatar(image, Config.AVATAR_FULL_SIZE);
617 return Futures.transformAsync(
618 infoFuture, avatars -> publish(avatars, open), MoreExecutors.directExecutor());
619 }
620
621 public boolean hasPepToVCardConversion() {
622 return getManager(DiscoManager.class).hasAccountFeature(Namespace.AVATAR_CONVERSION);
623 }
624
625 public ListenableFuture<Void> delete() {
626 final var pepManager = getManager(PepManager.class);
627 final var deleteMetaDataFuture = pepManager.delete(Namespace.AVATAR_METADATA);
628 final var deleteDataFuture = pepManager.delete(Namespace.AVATAR_DATA);
629 return Futures.transform(
630 Futures.allAsList(deleteDataFuture, deleteMetaDataFuture),
631 vs -> null,
632 MoreExecutors.directExecutor());
633 }
634
635 public ListenableFuture<Void> fetchAndStore(final Jid address) {
636 final var metaDataFuture =
637 getManager(PubSubManager.class).fetchItems(address, Metadata.class);
638 return Futures.transformAsync(
639 metaDataFuture,
640 metaData -> {
641 final var entry = Iterables.getFirst(metaData.entrySet(), null);
642 if (entry == null) {
643 throw new IllegalStateException("Metadata item not found");
644 }
645 final var avatar = getPreferredFallback(entry);
646
647 if (avatar == null) {
648 throw new IllegalStateException("No avatar found");
649 }
650
651 final var cache = FileBackend.getAvatarFile(context, avatar.preferred.getId());
652
653 if (cache.exists()) {
654 Log.d(
655 Config.LOGTAG,
656 "fetchAndStore. file existed " + cache.getAbsolutePath());
657 setAvatar(address, avatar.preferred);
658 return Futures.immediateVoidFuture();
659 } else {
660 final var future =
661 this.fetchAndStoreWithFallback(
662 address, avatar.preferred, avatar.fallback);
663 return Futures.transform(
664 future,
665 info -> {
666 setAvatar(address, info);
667 return null;
668 },
669 MoreExecutors.directExecutor());
670 }
671 },
672 MoreExecutors.directExecutor());
673 }
674
675 private static boolean moveAvatarIntoCache(final File randomFile, final File destination) {
676 synchronized (RENAME_LOCK) {
677 if (destination.exists()) {
678 return true;
679 }
680 final var directory = destination.getParentFile();
681 if (directory != null && directory.mkdirs()) {
682 Log.d(
683 Config.LOGTAG,
684 "create avatar cache directory: " + directory.getAbsolutePath());
685 }
686 return randomFile.renameTo(destination);
687 }
688 }
689
690 public ListenableFuture<Void> fetchAndStoreVCard(final Jid address, final String expectedHash) {
691 final var future = connection.getManager(VCardManager.class).retrievePhoto(address);
692 return Futures.transformAsync(
693 future,
694 photo -> {
695 final var actualHash = Hashing.sha1().hashBytes(photo).toString();
696 if (!actualHash.equals(expectedHash)) {
697 return Futures.immediateFailedFuture(
698 new IllegalStateException(
699 String.format(
700 "Hash in vCard update for %s did not match",
701 address)));
702 }
703 final var avatarFile = FileBackend.getAvatarFile(context, actualHash);
704 if (avatarFile.exists()) {
705 setAvatar(address, actualHash);
706 return Futures.immediateVoidFuture();
707 }
708 final var writeFuture = write(avatarFile, photo);
709 return Futures.transform(
710 writeFuture,
711 v -> {
712 setAvatar(address, actualHash);
713 return null;
714 },
715 MoreExecutors.directExecutor());
716 },
717 AVATAR_COMPRESSION_EXECUTOR);
718 }
719
720 public enum ImageFormat {
721 PNG,
722 JPEG,
723 WEBP,
724 HEIF,
725 AVIF;
726
727 public String toContentType() {
728 return switch (this) {
729 case WEBP -> "image/webp";
730 case PNG -> "image/png";
731 case JPEG -> "image/jpeg";
732 case AVIF -> "image/avif";
733 case HEIF -> "image/heif";
734 };
735 }
736
737 public static int formatPriority(final String type) {
738 final var format = ofContentType(type);
739 return format == null ? Integer.MIN_VALUE : format.ordinal();
740 }
741
742 private static ImageFormat ofContentType(final String type) {
743 return switch (type) {
744 case "image/png" -> PNG;
745 case "image/jpeg" -> JPEG;
746 case "image/webp" -> WEBP;
747 case "image/heif" -> HEIF;
748 case "image/avif" -> AVIF;
749 default -> null;
750 };
751 }
752
753 public static ImageFormat of(final Bitmap.CompressFormat compressFormat) {
754 return switch (compressFormat) {
755 case PNG -> PNG;
756 case WEBP -> WEBP;
757 case JPEG -> JPEG;
758 default -> throw new AssertionError("Not implemented");
759 };
760 }
761 }
762
763 private static final class PreferredFallback {
764 private final Info preferred;
765 private final Info fallback;
766
767 private PreferredFallback(final Info fallback) {
768 this(fallback, fallback);
769 }
770
771 private PreferredFallback(Info preferred, Info fallback) {
772 this.preferred = preferred;
773 this.fallback = fallback;
774 }
775 }
776}