Line data    Source code

       1             : /*
       2             :  *   Famedly Matrix SDK
       3             :  *   Copyright (C) 2020, 2021 Famedly GmbH
       4             :  *
       5             :  *   This program is free software: you can redistribute it and/or modify
       6             :  *   it under the terms of the GNU Affero General Public License as
       7             :  *   published by the Free Software Foundation, either version 3 of the
       8             :  *   License, or (at your option) any later version.
       9             :  *
      10             :  *   This program is distributed in the hope that it will be useful,
      11             :  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
      12             :  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
      13             :  *   GNU Affero General Public License for more details.
      14             :  *
      15             :  *   You should have received a copy of the GNU Affero General Public License
      16             :  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
      17             :  */
      18             : 
      19             : import 'package:slugify/slugify.dart';
      20             : 
      21             : import 'package:matrix/matrix_api_lite.dart';
      22             : import 'package:matrix/src/room.dart';
      23             : 
      24             : extension ImagePackRoomExtension on Room {
      25             :   /// Get all the active image packs for the specified [usage], mapped by their slug
      26           2 :   Map<String, ImagePackContent> getImagePacks([ImagePackUsage? usage]) {
      27             :     final allMxcs = <Uri>{}; // used for easy deduplication
      28           2 :     final packs = <String, ImagePackContent>{};
      29             : 
      30           2 :     void addImagePack(BasicEvent? event, {Room? room, String? slug}) {
      31             :       if (event == null) return;
      32           2 :       final imagePack = event.parsedImagePackContent;
      33           2 :       final finalSlug = slugify(slug ?? 'pack');
      34           6 :       for (final entry in imagePack.images.entries) {
      35           2 :         final image = entry.value;
      36           4 :         if (allMxcs.contains(image.url)) {
      37             :           continue;
      38             :         }
      39           6 :         final imageUsage = image.usage ?? imagePack.pack.usage;
      40             :         if (usage != null &&
      41             :             imageUsage != null &&
      42           2 :             !imageUsage.contains(usage)) {
      43             :           continue;
      44             :         }
      45             :         packs
      46           2 :             .putIfAbsent(
      47             :               finalSlug,
      48           6 :               () => ImagePackContent.fromJson({})
      49           8 :                 ..pack.displayName = imagePack.pack.displayName ??
      50           2 :                     room?.getLocalizedDisplayname() ??
      51             :                     finalSlug
      52          10 :                 ..pack.avatarUrl = imagePack.pack.avatarUrl ?? room?.avatar
      53           8 :                 ..pack.attribution = imagePack.pack.attribution,
      54             :             )
      55           6 :             .images[entry.key] = image;
      56           4 :         allMxcs.add(image.url);
      57             :       }
      58             :     }
      59             : 
      60             :     // first we add the user image pack
      61           8 :     addImagePack(client.accountData['im.ponies.user_emotes'], slug: 'user');
      62             :     // next we add all the external image packs
      63           6 :     final packRooms = client.accountData['im.ponies.emote_rooms'];
      64           4 :     final rooms = packRooms?.content.tryGetMap<String, Object?>('rooms');
      65             :     if (packRooms != null && rooms != null) {
      66           4 :       for (final roomEntry in rooms.entries) {
      67           2 :         final roomId = roomEntry.key;
      68           4 :         final room = client.getRoomById(roomId);
      69           2 :         final roomEntryValue = roomEntry.value;
      70           2 :         if (room != null && roomEntryValue is Map<String, Object?>) {
      71           4 :           for (final stateKeyEntry in roomEntryValue.entries) {
      72           2 :             final stateKey = stateKeyEntry.key;
      73             :             final fallbackSlug =
      74          10 :                 '${room.getLocalizedDisplayname()}-${stateKey.isNotEmpty ? '$stateKey-' : ''}${room.id}';
      75           2 :             addImagePack(
      76           2 :               room.getState('im.ponies.room_emotes', stateKey),
      77             :               room: room,
      78             :               slug: fallbackSlug,
      79             :             );
      80             :           }
      81             :         }
      82             :       }
      83             :     }
      84             :     // finally we add all of this rooms state
      85           4 :     final allRoomEmotes = states['im.ponies.room_emotes'];
      86             :     if (allRoomEmotes != null) {
      87           4 :       for (final entry in allRoomEmotes.entries) {
      88           2 :         addImagePack(
      89           2 :           entry.value,
      90             :           room: this,
      91           8 :           slug: (entry.value.stateKey?.isNotEmpty == true)
      92           4 :               ? entry.value.stateKey
      93             :               : 'room',
      94             :         );
      95             :       }
      96             :     }
      97             :     return packs;
      98             :   }
      99             : 
     100             :   /// Get a flat view of all the image packs of a specified [usage], that is a map of all
     101             :   /// slugs to a map of the image code to their mxc url
     102           2 :   Map<String, Map<String, String>> getImagePacksFlat([ImagePackUsage? usage]) =>
     103           4 :       getImagePacks(usage).map(
     104           2 :         (k, v) =>
     105          14 :             MapEntry(k, v.images.map((k, v) => MapEntry(k, v.url.toString()))),
     106             :       );
     107             : }