whatsapp 贴纸：不支持此文件格式

如何解决whatsapp 贴纸：不支持此文件格式

嗨，我已经使用内容提供程序实现了所有代码...我正在从图库中选择图像，然后转换为“webp”格式，但是当我将选择添加到 whatsapp 时，它显示“Whatsapp：不支持此格式一切都很好，即使我也下载了没有添加到 whatsappp 贴纸中的 webp 格式的选择，但显示同样的错误？

public class StickerContentProvider extends ContentProvider {   

    private List<StickerPack> stickerPackList;

    @Override
    public boolean onCreate() {
        final String authority = CONTENT_PROVIDER_AUTHORITY;
        if (!authority.startsWith(Objects.requireNonNull(getContext()).getPackageName())) {
            throw new IllegalStateException("your authority (" + authority + ") for the content provider should start with your package name: " + getContext().getPackageName());
        }

        MATCHER.addURI(authority,METADATA,METADATA_CODE);

        MATCHER.addURI(authority,METADATA + "/*",METADATA_CODE_FOR_SINGLE_PACK);

        MATCHER.addURI(authority,STICKERS + "/*",STICKERS_CODE);

        for (StickerPack stickerPack : getStickerPackList()) {
            MATCHER.addURI(authority,STICKERS_ASSET + "/" + stickerPack.identifier + "/" + stickerPack.trayImageFile,STICKER_PACK_TRAY_ICON_CODE);
            for (Sticker sticker : stickerPack.getStickers()) {
                MATCHER.addURI(authority,STICKERS_ASSET + "/" + stickerPack.identifier + "/" + sticker.imageFileName,STICKERS_ASSET_CODE);
            }
        }

        return true;
    }

    @Override
    public Cursor query(@NonNull Uri uri,@Nullable String[] projection,String selection,String[] selectionArgs,String sortOrder) {
        final int code = MATCHER.match(uri);
        Log.w("BASIC Query URI",String.valueOf(uri));
        if(StickerBook.getAllStickerPacks().isEmpty()){
            StickerBook.init(getContext());
        }
        if (code == METADATA_CODE) {
            return getPackForAllStickerPacks(uri);
        } else if (code == METADATA_CODE_FOR_SINGLE_PACK) {
            return getCursorForSingleStickerPack(uri);
        } else if (code == STICKERS_CODE) {
            return getStickersForAStickerPack(uri);
        } else {
            throw new IllegalArgumentException("Unknown URI: " + uri);
        }
    }

    @Nullable
    @Override
    public AssetFileDescriptor openAssetFile(@NonNull Uri uri,@NonNull String mode) {
        final int matchCode = MATCHER.match(uri);
        Log.w("ASSETFILE QUERY URI",String.valueOf(uri) + "");
        Log.w("ASSETFILE QUERY PATH",uri.getPath() + "");
        final List<String> pathSegments = uri.getPathSegments();
        StickerPack csp = StickerBook.getStickerPackByIdWithContext(pathSegments.get(pathSegments.size() - 2),getContext());
        if(csp!=null){
            String filename = pathSegments.get(pathSegments.size() - 1);


            ParcelFileDescriptor pfd = null;
            try {
                if(filename.equals("trayimage") && csp.getTrayImageUri()!=null){
                    pfd = Objects.requireNonNull(getContext()).getContentResolver().openFileDescriptor(
                            csp.getTrayImageUri(),"r");
                    Log.e("ASSETFILE ACTUAL URI",String.valueOf(csp.getTrayImageUri()) + "");

                } else {
                    try {
                        pfd = Objects.requireNonNull(getContext()).getContentResolver().openFileDescriptor(
                                csp.getStickerById(Integer.valueOf(filename)).getUri(),"r");
                        Log.w("ASSETFILE ACTUAL URI",String.valueOf(csp.getStickerById(Integer.valueOf(filename)).getUri()) + "");
                    } catch (NullPointerException e){
                        Log.e("StickerMaker","WhatsApp tried to access a non existent sticker,id: " + filename);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

            return new AssetFileDescriptor(pfd,AssetFileDescriptor.UNKNOWN_LENGTH);
        }
        return getImageAsset(uri);

    }

    @Nullable
    @Override
    public ParcelFileDescriptor openFile(@NonNull Uri uri,@NonNull String mode) throws FileNotFoundException {
        Log.w("TESTING THIS","IS IT OPENING FILE REGULARLY?");
        return super.openFile(uri,mode);
    }

    @Override
    public String getType(@NonNull Uri uri) {
        final int matchCode = MATCHER.match(uri);
        switch (matchCode) {
            case METADATA_CODE:
                return "vnd.android.cursor.dir/vnd." + CONTENT_PROVIDER_AUTHORITY + "." + METADATA;
            case METADATA_CODE_FOR_SINGLE_PACK:
                return "vnd.android.cursor.item/vnd." + CONTENT_PROVIDER_AUTHORITY + "." + METADATA;
            case STICKERS_CODE:
                return "vnd.android.cursor.dir/vnd." + CONTENT_PROVIDER_AUTHORITY + "." + STICKERS;
            case STICKERS_ASSET_CODE:
                return "image/webp";
            case STICKER_PACK_TRAY_ICON_CODE:
                return "image/png";
            default:
                throw new IllegalArgumentException("Unknown URI: " + uri);
        }
    }

    public List<StickerPack> getStickerPackList() {
        /*if (stickerPackList == null) {
            readContentFile();
        }*/
        stickerPackList = StickerBook.getAllStickerPacks();
        return stickerPackList;
    }


    private Cursor getPackForAllStickerPacks(@NonNull Uri uri) {
        return getStickerPackInfo(uri,getStickerPackList());
    }

    private Cursor getCursorForSingleStickerPack(@NonNull Uri uri) {
        final String identifier = uri.getLastPathSegment();
        for (StickerPack stickerPack : getStickerPackList()) {
            if (identifier.equals(stickerPack.identifier)) {
                return getStickerPackInfo(uri,Collections.singletonList(stickerPack));
            }
        }

        return getStickerPackInfo(uri,new ArrayList<StickerPack>());
    }

    @NonNull
    private Cursor getStickerPackInfo(@NonNull Uri uri,@NonNull List<StickerPack> stickerPackList) {
        MatrixCursor cursor = new MatrixCursor(
                new String[]{
                        STICKER_PACK_IDENTIFIER_IN_QUERY,STICKER_PACK_NAME_IN_QUERY,STICKER_PACK_PUBLISHER_IN_QUERY,STICKER_PACK_ICON_IN_QUERY,ANDROID_APP_DOWNLOAD_LINK_IN_QUERY,IOS_APP_DOWNLOAD_LINK_IN_QUERY,PUBLISHER_EMAIL,PUBLISHER_WEBSITE,PRIVACY_POLICY_WEBSITE,LICENSE_AGREENMENT_WEBSITE
                });
        for (StickerPack stickerPack : stickerPackList) {
            MatrixCursor.RowBuilder builder = cursor.newRow();
            builder.add(stickerPack.identifier);
            builder.add(stickerPack.name);
            builder.add(stickerPack.publisher);
            builder.add(stickerPack.trayImageFile);
            builder.add(stickerPack.androidPlayStoreLink);
            builder.add(stickerPack.iosAppStoreLink);
            builder.add(stickerPack.publisherEmail);
            builder.add(stickerPack.publisherWebsite);
            builder.add(stickerPack.privacyPolicyWebsite);
            builder.add(stickerPack.licenseAgreementWebsite);
        }
        cursor.setNotificationUri(Objects.requireNonNull(getContext()).getContentResolver(),uri);
        return cursor;
    }

    @NonNull
    private Cursor getStickersForAStickerPack(@NonNull Uri uri) {
        final String identifier = uri.getLastPathSegment();
        MatrixCursor cursor = new MatrixCursor(new String[]{STICKER_FILE_NAME_IN_QUERY,STICKER_FILE_EMOJI_IN_QUERY});
        for (StickerPack stickerPack : getStickerPackList()) {
            if (identifier.equals(stickerPack.identifier)) {
                for (Sticker sticker : stickerPack.getStickers()) {
                    cursor.addRow(new Object[]{sticker.imageFileName,TextUtils.join(",",sticker.emojis)});
                }
            }
        }
        cursor.setNotificationUri(Objects.requireNonNull(getContext()).getContentResolver(),uri);
        return cursor;
    }

    private AssetFileDescriptor getImageAsset(Uri uri) throws IllegalArgumentException {
        Log.w("IMAGE ASSET","ASKING FOR ASSET?");
        AssetManager am = Objects.requireNonNull(getContext()).getAssets();
        final List<String> pathSegments = uri.getPathSegments();
        if (pathSegments.size() != 3) {
            throw new IllegalArgumentException("path segments should be 3,uri is: " + uri);
        }
        String fileName = pathSegments.get(pathSegments.size() - 1);
        final String identifier = pathSegments.get(pathSegments.size() - 2);
        if (TextUtils.isEmpty(identifier)) {
            throw new IllegalArgumentException("identifier is empty,uri: " + uri);
        }
        if (TextUtils.isEmpty(fileName)) {
            throw new IllegalArgumentException("file name is empty,uri: " + uri);
        }
        //making sure the file that is trying to be fetched is in the list of stickers.
        for (StickerPack stickerPack : getStickerPackList()) {
            if (identifier.equals(stickerPack.identifier)) {
                if (fileName.equals(stickerPack.trayImageFile)) {
                    return fetchFile(uri,am,fileName,identifier);
                } else {
                    for (Sticker sticker : stickerPack.getStickers()) {
                        if (fileName.equals(sticker.imageFileName)) {
                            return fetchFile(uri,identifier);
                        }
                    }
                }
            }
        }
        return null;
    }

    private AssetFileDescriptor fetchFile(@NonNull Uri uri,@NonNull AssetManager am,@NonNull String fileName,@NonNull String identifier) {
        try {
            return am.openFd(identifier + "/" + fileName);
        } catch (IOException e) {
            Log.e(Objects.requireNonNull(getContext()).getPackageName(),"IOException when getting asset file,uri:" + uri,e);
            return null;
        }
    }


    @Override
    public int delete(@NonNull Uri uri,@Nullable String selection,String[] selectionArgs) {
        throw new UnsupportedOperationException("Not supported");
    }

    @Override
    public Uri insert(@NonNull Uri uri,ContentValues values) {
        throw new UnsupportedOperationException("Not supported");
    }

    @Override
    public int update(@NonNull Uri uri,ContentValues values,String[] selectionArgs) {
        throw new UnsupportedOperationException("Not supported");
    }
}