API tools faq
paste
adityaspt

Untitled

adityaspt
Jun 11th, 2020
310
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 22.22 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * Copyright (c) WhatsApp Inc. and its affiliates.
  3.  * All rights reserved.
  4.  *
  5.  * This source code is licensed under the BSD-style license found in the
  6.  * LICENSE file in the root directory of this source tree.
  7.  */
  8.  
  9. package com.plugin.unityapp;
  10. //import android.support.v4.content.FileProvider;
  11. import android.content.ContentProvider;
  12. import android.content.ContentResolver;
  13. import android.content.ContentValues;
  14. import android.content.Context;
  15. import android.content.SharedPreferences;
  16. import android.content.UriMatcher;
  17. import android.content.res.AssetFileDescriptor;
  18. import android.content.res.AssetManager;
  19. import android.database.Cursor;
  20. import android.database.MatrixCursor;
  21. import android.net.Uri;
  22. import android.os.Environment;
  23. import android.os.ParcelFileDescriptor;
  24. import android.preference.PreferenceManager;
  25. import android.text.TextUtils;
  26. import android.util.Log;
  27.  
  28. import androidx.annotation.NonNull;
  29. import androidx.annotation.Nullable;
  30.  
  31. import java.io.BufferedReader;
  32. import java.io.File;
  33. import java.io.FileInputStream;
  34. import java.io.FileNotFoundException;
  35. import java.io.FileOutputStream;
  36. import java.io.IOException;
  37. import java.io.InputStream;
  38. import java.io.InputStreamReader;
  39. import java.io.OutputStream;
  40. import java.util.ArrayList;
  41. import java.util.Collections;
  42. import java.util.List;
  43. import java.util.Objects;
  44.  
  45. public class StickerContentProvider extends ContentProvider {
  46.  
  47.     /**
  48.      * Do not change the strings listed below, as these are used by WhatsApp. And changing these will break the interface between sticker app and WhatsApp.
  49.      */
  50.     public static final String STICKER_PACK_IDENTIFIER_IN_QUERY = "sticker_pack_identifier";
  51.     public static final String STICKER_PACK_NAME_IN_QUERY = "sticker_pack_name";
  52.     public static final String STICKER_PACK_PUBLISHER_IN_QUERY = "sticker_pack_publisher";
  53.     public static final String STICKER_PACK_ICON_IN_QUERY = "sticker_pack_icon";
  54.     public static final String ANDROID_APP_DOWNLOAD_LINK_IN_QUERY = "android_play_store_link";
  55.     public static final String IOS_APP_DOWNLOAD_LINK_IN_QUERY = "ios_app_download_link";
  56.     public static final String PUBLISHER_EMAIL = "sticker_pack_publisher_email";
  57.     public static final String PUBLISHER_WEBSITE = "sticker_pack_publisher_website";
  58.     public static final String PRIVACY_POLICY_WEBSITE = "sticker_pack_privacy_policy_website";
  59.     public static final String LICENSE_AGREENMENT_WEBSITE = "sticker_pack_license_agreement_website";
  60.     public static final String IMAGE_DATA_VERSION = "image_data_version";
  61.     public static final String AVOID_CACHE = "whatsapp_will_not_cache_stickers";
  62.  
  63.     public static final String STICKER_FILE_NAME_IN_QUERY = "sticker_file_name";
  64.     public static final String STICKER_FILE_EMOJI_IN_QUERY = "sticker_emoji";
  65.     private static final String CONTENT_FILE_NAME = "contents.json";
  66.  
  67.   //  public static final Uri AUTHORITY_URI = new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).authority(BuildConfig.CONTENT_PROVIDER_AUTHORITY).appendPath(StickerContentProvider.METADATA).build();
  68.   public static final Uri AUTHORITY_URI = new Uri.Builder().scheme(ContentResolver.SCHEME_CONTENT).authority(BuildConfig.CONTENT_PROVIDER_AUTHORITY).appendPath(StickerContentProvider.METADATA).build();
  69.     /**
  70.      * Do not change the values in the UriMatcher because otherwise, WhatsApp will not be able to fetch the stickers from the ContentProvider.
  71.      */
  72.     private static final UriMatcher MATCHER = new UriMatcher(UriMatcher.NO_MATCH);
  73.     private static final String METADATA = "metadata";
  74.     private static final int METADATA_CODE = 1;
  75.  
  76.     private static final int METADATA_CODE_FOR_SINGLE_PACK = 2;
  77.  
  78.     static final String STICKERS = "stickers";
  79.     private static final int STICKERS_CODE = 3;
  80.  
  81.     static final String STICKERS_ASSET = "stickers_asset";
  82.     private static final int STICKERS_ASSET_CODE = 4;
  83.  
  84.     private static final int STICKER_PACK_TRAY_ICON_CODE = 5;
  85.  
  86.     private List<StickerPack> stickerPackList;
  87.     public static final String PREFS_NAME = "MyPrefsFile";
  88.     @Override
  89.     public boolean onCreate() {
  90.         final String authority = BuildConfig.CONTENT_PROVIDER_AUTHORITY;
  91.         if (!authority.startsWith(Objects.requireNonNull(getContext()).getPackageName())) {
  92.             throw new IllegalStateException("your authority (" + authority + ") for the content provider should start with your package name: " + getContext().getPackageName());
  93.         }
  94.  
  95. //Write json from plugin assets to internal storage android/data/packagename/files/
  96. //        String fileNAME = "contents.json";
  97. //        File file = new File(String.valueOf(getContext().getExternalFilesDir("contents.json")));
  98. //        if(file.exists()){
  99. //            //Do something
  100. //            Log.i("UnityAndroid","file already exists");
  101. //
  102. //        }
  103. //        else{
  104. //            Log.i("UnityAndroid","file does not exists ,adding new one");
  105.             //Nothing
  106.             copyAssets();
  107.      //   }
  108.  
  109.  
  110. //        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(getContext());
  111. //        if (!prefs.getBoolean("firstTime", false)) {
  112. //            // <---- run your one time code here
  113.            //copyAssets();
  114.  
  115.             // mark first time has ran.
  116. //            SharedPreferences.Editor editor = prefs.edit();
  117. //            editor.putBoolean("firstTime", true);
  118. //            editor.commit();
  119. //        }
  120.  
  121.  
  122.  
  123.         //SharedPreferences playerPrefs = getContext().getSharedPreferences("com.idzgame.CatPun1" + ".v2.playerprefs", Context.MODE_PRIVATE); //getActivity().getPreferences(Context.MODE_PRIVATE);
  124.  
  125.        // SharedPreferences playerPrefs = getContext().getSharedPreferences(getContext().getPackageName() + ".playerprefs", Context.MODE_PRIVATE);
  126.  
  127.         //playerPrefs.getStringSet("ABC","Hello from Android playerPrefs");
  128.         //playerPrefs.editor().putString(“Key”,”value”).apply();
  129.  
  130.           //      playerPrefs.edit().putString("ABC","Hello from Android playerPrefs").apply();
  131.  
  132. //setPreferenceString("ABC","Hello from Android playerPrefs");
  133.  
  134.  
  135.  
  136.  
  137.  
  138.  
  139.     //String name = prefs.getString("userName", "");
  140.         //the call to get the metadata for the sticker packs.
  141.         MATCHER.addURI(authority, METADATA, METADATA_CODE);
  142.  
  143.         //the call to get the metadata for single sticker pack. * represent the identifier
  144.         MATCHER.addURI(authority, METADATA + "/*", METADATA_CODE_FOR_SINGLE_PACK);
  145.  
  146.         //gets the list of stickers for a sticker pack, * respresent the identifier.
  147.         MATCHER.addURI(authority, STICKERS + "/*", STICKERS_CODE);
  148. //if(AddStickersClass.StickerClicked) {
  149.     for (StickerPack stickerPack : getStickerPackList()) {
  150.         MATCHER.addURI(authority, STICKERS_ASSET + "/" + stickerPack.identifier + "/" + stickerPack.trayImageFile, STICKER_PACK_TRAY_ICON_CODE);
  151.         for (Sticker sticker : stickerPack.getStickers()) {
  152.             MATCHER.addURI(authority, STICKERS_ASSET + "/" + stickerPack.identifier + "/" + sticker.imageFileName, STICKERS_ASSET_CODE);
  153.         }
  154.     }
  155. //}
  156.         return true;
  157.     }
  158.  
  159.     //Not working
  160.     public void setPreferenceString (String prefKey, String prefValue) {
  161.         SharedPreferences settings = getContext().getSharedPreferences("com.idzgame.CatPun1" + ".v2.playerprefs", Context.MODE_PRIVATE);//.getSharedPreferences(PREFS_NAME, 0);
  162.         SharedPreferences.Editor editor = settings.edit();
  163.         editor.putString(prefKey, prefValue);
  164.         editor.commit();
  165.  
  166.     }
  167.  
  168.     public String getPreferenceString (String prefKey) {
  169.         SharedPreferences settings = getContext().getSharedPreferences("com.idzgame.CatPun1" + ".v2.playerprefs", Context.MODE_PRIVATE);//.getSharedPreferences(PREFS_NAME, 0);
  170.         String playerName = settings.getString(prefKey, "");
  171.         return playerName;
  172.     }
  173.     //
  174.  
  175.     private void copyAssets() {
  176.         Log.i("UnityAndroid","Copyassets function called");
  177.      //   String fileNAME = "contents.json";
  178. //        File file = new File(getContext().getExternalFilesDir(null),"contents.json");
  179. //        if(file.exists()){
  180. //            //Do something
  181. //            Log.i("UnityAndroid","file already exists");
  182. //
  183. //        }
  184. //        else{
  185. //            Log.i("UnityAndroid","file does not exists ,adding new one");
  186. //            //Nothing
  187. //           // copyAssets();
  188. //        }
  189.         AssetManager assetManager = getContext().getAssets();
  190.         String[] files = null;
  191.         try {
  192.             files = assetManager.list("");
  193.         } catch (IOException e) {
  194.             Log.e("tag", "Failed to get asset file list.", e);
  195.         }
  196.         if (files != null) for (String filename : files) {
  197.           //   if(filename==fileNAME){
  198.             InputStream in = null;
  199.             OutputStream out = null;
  200.             try {
  201.                 in = assetManager.open(filename);
  202.                 File outFile = new File(getContext().getExternalFilesDir(null), filename);
  203.                 out = new FileOutputStream(outFile);
  204.                 copyFile(in, out);
  205.             } catch (IOException e) {
  206.                 Log.e("tag", "Failed to copy asset file: " + filename, e);
  207.             } finally {
  208.                 if (in != null) {
  209.                     try {
  210.                         in.close();
  211.                     } catch (IOException e) {
  212.                         // NOOP
  213.                     }
  214.                 }
  215.                 if (out != null) {
  216.                     try {
  217.                         out.close();
  218.                     } catch (IOException e) {
  219.                         // NOOP
  220.                     }
  221.                 }
  222.             }
  223.        // }
  224.     }
  225.     }
  226.  
  227.         private void copyFile(InputStream in, OutputStream out) throws IOException {
  228.             byte[] buffer = new byte[1024];
  229.             int read;
  230.             while((read = in.read(buffer)) != -1){
  231.                 out.write(buffer, 0, read);
  232.                 Log.i("UnityAndroid","Writing file");
  233.             }
  234.         }
  235.     //
  236.  
  237.  
  238.  
  239.     @Override
  240.     public Cursor query(@NonNull Uri uri, @Nullable String[] projection, String selection,
  241.                         String[] selectionArgs, String sortOrder) {
  242.         final int code = MATCHER.match(uri);
  243.         if (code == METADATA_CODE) {
  244.             return getPackForAllStickerPacks(uri);
  245.         } else if (code == METADATA_CODE_FOR_SINGLE_PACK) {
  246.             return getCursorForSingleStickerPack(uri);
  247.         } else if (code == STICKERS_CODE) {
  248.             return getStickersForAStickerPack(uri);
  249.         } else {
  250.             throw new IllegalArgumentException("Unknown URI: " + uri);
  251.         }
  252.     }
  253.  
  254.     @Nullable
  255.     @Override
  256.     public AssetFileDescriptor openAssetFile(@NonNull Uri uri, @NonNull String mode) {
  257.         final int matchCode = MATCHER.match(uri);
  258.         if (matchCode == STICKERS_ASSET_CODE || matchCode == STICKER_PACK_TRAY_ICON_CODE) {
  259.             try {
  260.                 return getImageAsset(uri);
  261.             } catch (IOException e) {
  262.                 e.printStackTrace();
  263.             }
  264.         }
  265.         return null;
  266.     }
  267.  
  268.  
  269.     @Override
  270.     public String getType(@NonNull Uri uri) {
  271.         final int matchCode = MATCHER.match(uri);
  272.         switch (matchCode) {
  273.             case METADATA_CODE:
  274.                 return "vnd.android.cursor.dir/vnd." + BuildConfig.CONTENT_PROVIDER_AUTHORITY + "." + METADATA;
  275.             case METADATA_CODE_FOR_SINGLE_PACK:
  276.                 return "vnd.android.cursor.item/vnd." + BuildConfig.CONTENT_PROVIDER_AUTHORITY + "." + METADATA;
  277.             case STICKERS_CODE:
  278.                 return "vnd.android.cursor.dir/vnd." + BuildConfig.CONTENT_PROVIDER_AUTHORITY + "." + STICKERS;
  279.             case STICKERS_ASSET_CODE:
  280.                 return "image/webp";
  281.             case STICKER_PACK_TRAY_ICON_CODE:
  282.                 return "image/png";
  283.             default:
  284.                 throw new IllegalArgumentException("Unknown URI: " + uri);
  285.         }
  286.     }
  287.  
  288. //    private synchronized void readContentFile(@NonNull Context context)  {
  289. //
  290. //        File file_name=context.getExternalFilesDir("contents.json") ;
  291. //        if(file_name.exists()){
  292. //            //Do something
  293. //            Log.i("UnityAndroid","file already exists");
  294. //            try {
  295. //
  296. //                InputStream inputStream = new FileInputStream((file_name));
  297. //                try (InputStream contentsInputStream = inputStream ) {
  298. //                    stickerPackList = ContentFileParser.parseStickerPacks(contentsInputStream);
  299. //                } catch (IOException | IllegalStateException e) {
  300. //                    throw new RuntimeException(CONTENT_FILE_NAME + " file has some issues: " + e.getMessage(), e);
  301. //                }
  302. //            }
  303. //            catch(IOException | IllegalStateException e) {
  304. //                throw new RuntimeException(CONTENT_FILE_NAME + " file has some issues: " + e.getMessage(), e);
  305. //            }
  306. //        }
  307. //        else{
  308. //            Log.i("UnityAndroid","file does not exists ,adding new one");
  309. //                    try (InputStream contentsInputStream = context.getAssets().open(CONTENT_FILE_NAME)) {
  310. //            stickerPackList = ContentFileParser.parseStickerPacks(contentsInputStream);
  311. //        } catch (IOException | IllegalStateException e) {
  312. //            throw new RuntimeException(CONTENT_FILE_NAME + " file has some issues: " + e.getMessage(), e);
  313. //        }
  314. //    }
  315.  //       }
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.     public synchronized void readContentFile(@NonNull Context context)  { //Previosuly working
  325.  
  326.         File file_name=context.getExternalFilesDir("contents.json") ;
  327.  
  328.         try {
  329.  
  330.             InputStream inputStream = new FileInputStream((file_name));
  331.             try (InputStream contentsInputStream = inputStream ) {
  332.                 stickerPackList = ContentFileParser.parseStickerPacks(contentsInputStream);
  333.                 Log.i("StickerList ", "Read from the list" );
  334.                 Log.i("StickerList ", "Image Data Version "+stickerPackList.get(0).imageDataVersion);
  335.                 for(int i=0;i<stickerPackList.get(0).getStickers().size();i++){
  336.                     Log.i("StickerList " ,"Sticker num "+i+" "+stickerPackList.get(0).getStickers().get(i).imageFileName);
  337.                 }
  338.  
  339.  
  340.             } catch (IOException | IllegalStateException e) {
  341.                 throw new RuntimeException(CONTENT_FILE_NAME + " file has some issues: " + e.getMessage(), e);
  342.             }
  343.         }
  344.         catch(IOException | IllegalStateException e) {
  345.             throw new RuntimeException(CONTENT_FILE_NAME + " file has some issues: " + e.getMessage(), e);
  346.         }
  347.  
  348.  
  349.     }
  350.  
  351.  
  352.  
  353.  
  354.  
  355. //    private synchronized void readContentImageFile(@NonNull Context context) {
  356. //        try (InputStream contentsInputStream = context.getAssets().open(CONTENT_FILE_NAME)) {
  357. //            stickerPackList = ContentFileParser.parseStickerPacks(contentsInputStream);
  358. //        } catch (IOException | IllegalStateException e) {
  359. //            throw new RuntimeException(CONTENT_FILE_NAME + " file has some issues: " + e.getMessage(), e);
  360. //        }
  361. //    }
  362.  
  363.  
  364.     private List<StickerPack> getStickerPackList() {
  365.        // if (stickerPackList == null) {
  366.             readContentFile(Objects.requireNonNull(getContext()));
  367.       //  }
  368.         return stickerPackList;
  369.     }
  370. //    private List<StickerPack> getStickerImagePackList() {
  371. //        // if (stickerPackList == null) {
  372. //        readContentImageFile(Objects.requireNonNull(getContext()));
  373. //        //  }
  374. //        return stickerPackList;
  375. //    }
  376.  
  377.     private Cursor getPackForAllStickerPacks(@NonNull Uri uri) {
  378.         return getStickerPackInfo(uri, getStickerPackList());
  379.     }
  380.  
  381.     private Cursor getCursorForSingleStickerPack(@NonNull Uri uri) {
  382.         final String identifier = uri.getLastPathSegment();
  383.         for (StickerPack stickerPack : getStickerPackList()) {
  384.             if (identifier.equals(stickerPack.identifier)) {
  385.                 return getStickerPackInfo(uri, Collections.singletonList(stickerPack));
  386.             }
  387.         }
  388.  
  389.         return getStickerPackInfo(uri, new ArrayList<StickerPack>()); // Adi
  390.     }
  391.  
  392.     @NonNull
  393.     private Cursor getStickerPackInfo(@NonNull Uri uri, @NonNull List<StickerPack> stickerPackList) {
  394.         MatrixCursor cursor = new MatrixCursor(
  395.                 new String[]{
  396.                         STICKER_PACK_IDENTIFIER_IN_QUERY,
  397.                         STICKER_PACK_NAME_IN_QUERY,
  398.                         STICKER_PACK_PUBLISHER_IN_QUERY,
  399.                         STICKER_PACK_ICON_IN_QUERY,
  400.                         ANDROID_APP_DOWNLOAD_LINK_IN_QUERY,
  401.                         IOS_APP_DOWNLOAD_LINK_IN_QUERY,
  402.                         PUBLISHER_EMAIL,
  403.                         PUBLISHER_WEBSITE,
  404.                         PRIVACY_POLICY_WEBSITE,
  405.                         LICENSE_AGREENMENT_WEBSITE,
  406.                         IMAGE_DATA_VERSION,
  407.                         AVOID_CACHE,
  408.                 });
  409.         for (StickerPack stickerPack : stickerPackList) {
  410.             MatrixCursor.RowBuilder builder = cursor.newRow();
  411.             builder.add(stickerPack.identifier);
  412.             builder.add(stickerPack.name);
  413.             builder.add(stickerPack.publisher);
  414.             builder.add(stickerPack.trayImageFile);
  415.             builder.add(stickerPack.androidPlayStoreLink);
  416.             builder.add(stickerPack.iosAppStoreLink);
  417.             builder.add(stickerPack.publisherEmail);
  418.             builder.add(stickerPack.publisherWebsite);
  419.             builder.add(stickerPack.privacyPolicyWebsite);
  420.             builder.add(stickerPack.licenseAgreementWebsite);
  421.             builder.add(stickerPack.imageDataVersion);
  422.             builder.add(stickerPack.avoidCache ? 1 : 0);
  423.         }
  424.         cursor.setNotificationUri(Objects.requireNonNull(getContext()).getContentResolver(), uri);
  425.         return cursor;
  426.     }
  427.  
  428.     @NonNull
  429.     private Cursor getStickersForAStickerPack(@NonNull Uri uri) {
  430.         final String identifier = uri.getLastPathSegment();
  431.         MatrixCursor cursor = new MatrixCursor(new String[]{STICKER_FILE_NAME_IN_QUERY, STICKER_FILE_EMOJI_IN_QUERY});
  432.         for (StickerPack stickerPack : getStickerPackList()) {
  433.             if (identifier.equals(stickerPack.identifier)) {
  434.                 for (Sticker sticker : stickerPack.getStickers()) {
  435.                     cursor.addRow(new Object[]{sticker.imageFileName, TextUtils.join(",", sticker.emojis)});
  436.                 }
  437.             }
  438.         }
  439.         cursor.setNotificationUri(Objects.requireNonNull(getContext()).getContentResolver(), uri);
  440.         return cursor;
  441.     }
  442.  
  443.     private AssetFileDescriptor getImageAsset(Uri uri) throws IllegalArgumentException, IOException {
  444.         AssetManager am = Objects.requireNonNull(getContext()).getAssets();
  445.         final List<String> pathSegments = uri.getPathSegments();
  446.         if (pathSegments.size() != 3) {
  447.             throw new IllegalArgumentException("path segments should be 3, uri is: " + uri);
  448.         }
  449.         String fileName = pathSegments.get(pathSegments.size() - 1);
  450.         final String identifier = pathSegments.get(pathSegments.size() - 2);
  451.         if (TextUtils.isEmpty(identifier)) {
  452.             throw new IllegalArgumentException("identifier is empty, uri: " + uri);
  453.         }
  454.         if (TextUtils.isEmpty(fileName)) {
  455.             throw new IllegalArgumentException("file name is empty, uri: " + uri);
  456.         }
  457.         //making sure the file that is trying to be fetched is in the list of stickers.
  458.         for (StickerPack stickerPack : getStickerPackList()) { //Changed
  459.             if (identifier.equals(stickerPack.identifier)) {
  460.                 if (fileName.equals(stickerPack.trayImageFile)) {
  461.                     return fetchFile(uri, am, fileName, identifier);
  462.                 } else {
  463.                     for (Sticker sticker : stickerPack.getStickers()) {
  464.                         if (fileName.equals(sticker.imageFileName)) {
  465.                             return fetchFile(uri, am, fileName, identifier);
  466.                         }
  467.                     }
  468.                 }
  469.             }
  470.         }
  471.         return null;
  472.     }
  473.  
  474. //    private AssetFileDescriptor fetchFile(@NonNull Uri uri, @NonNull AssetManager am, @NonNull String fileName, @NonNull String identifier) throws IOException {
  475. //        File cacheFile=getContext().getExternalFilesDir("contents.json") ; //
  476. //        //final File cacheFile = getContext().getExternalCacheDir();
  477. //        final File file = new File(cacheFile, "contents.json");
  478. //        try (final InputStream open = am.open(identifier + "/" + fileName);
  479. //             final FileOutputStream fileOutputStream = new FileOutputStream(file)) {
  480. //            byte[] buffer = new byte[1024];
  481. //            int read;
  482. //            while ((read = open.read(buffer)) != -1) {
  483. //                fileOutputStream.write(buffer, 0, read);
  484. //            }
  485. //        }
  486. //
  487. //        //The code above is basically copying the assets to storage, and servering the file off of the storage.
  488. //        //If you have the files already downloaded/fetched, you could simply replace above part, and initialize the file parameter with your own file which points to the desired file.
  489. //        //The key here is you can use ParcelFileDescriptor to create an AssetFileDescriptor.
  490. //        return new AssetFileDescriptor(ParcelFileDescriptor.open(file, ParcelFileDescriptor.MODE_READ_ONLY), 0, AssetFileDescriptor.UNKNOWN_LENGTH);
  491. //    }
  492.  
  493.     private AssetFileDescriptor fetchFile(@NonNull Uri uri, @NonNull AssetManager am, @NonNull String fileName, @NonNull String identifier) {
  494.         try {
  495.             return am.openFd(identifier + "/" + fileName);
  496.         } catch (IOException e) {
  497.             Log.e(Objects.requireNonNull(getContext()).getPackageName(), "IOException when getting asset file, uri:" + uri, e);
  498.             return null;
  499.         }
  500.     }
  501.  
  502.  
  503.     @Override
  504.     public int delete(@NonNull Uri uri, @Nullable String selection, String[] selectionArgs) {
  505.         throw new UnsupportedOperationException("Not supported");
  506.     }
  507.  
  508.     @Override
  509.     public Uri insert(@NonNull Uri uri, ContentValues values) {
  510.         throw new UnsupportedOperationException("Not supported");
  511.     }
  512.  
  513.     @Override
  514.     public int update(@NonNull Uri uri, ContentValues values, String selection,
  515.                       String[] selectionArgs) {
  516.         throw new UnsupportedOperationException("Not supported");
  517.     }
  518. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!