Merge branch 'IT18109672' into 'master'

It18109672

See merge request !18

.idea/jarRepositories.xml

@@ -21,5 +21,10 @@
       <option name="name" value="Google" />
       <option name="url" value="https://dl.google.com/dl/android/maven2/" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven" />
+      <option name="name" value="maven" />
+      <option name="url" value="https://jitpack.io" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file

app/build.gradle

@@ -72,6 +72,14 @@ dependencies {
     //Ui
     implementation "com.airbnb.android:lottie:3.7.0"
 
+    implementation 'com.github.QuadFlask:colorpicker:0.0.13'
+    implementation 'org.jsoup:jsoup:1.8.3'
+    implementation 'com.github.warkiz.tickseekbar:tickseekbar:0.1.4'
+    implementation 'net.alhazmy13.ImageFilters:library:0.1.2-beta'
+    implementation 'de.hdodenhof:circleimageview:3.1.0'
+    implementation 'info.androidhive:imagefilters:1.0.7'
+    implementation 'com.github.chuross:expandable-layout:1.0.5'
+
     testImplementation 'junit:junit:4.+'
     androidTestImplementation 'androidx.test.ext:junit:1.1.2'
     androidTestImplementation 'androidx.test.espresso:espresso-core:3.3.0'

app/src/main/AndroidManifest.xml

@@ -16,7 +16,6 @@
         android:theme="@style/Theme.SmartPhotoEditor">
 
         <activity android:name=".activities.DenoisingActivity" />
-        <activity android:name=".adapters.LoadingDialogAdapter" />
         <activity android:name=".activities.MyGallery"/>
         <activity android:name=".activities.CropActivity"/>
 
@@ -26,8 +25,7 @@
 
         </activity>
         <activity android:name=".activities.CameraView" />
-        <activity android:name=".activities.EyeBlink">
-        </activity>
+
         <activity android:name=".activities.EnvironmentChecker" />
         <activity
             android:name=".activities.SplashScreen"
@@ -40,7 +38,44 @@
             </intent-filter>
 
         </activity>
-        <activity android:name=".activities.EditorActivity" />
+        <activity android:name=".activities.EditorActivity" android:theme="@style/Theme.SmartPhotoEditor_action_bar" />
+
+
+        <activity
+            android:name=".activities.AddStickerOnImage"
+            android:screenOrientation="portrait"
+            />
+        <activity
+            android:name=".activities.PhotoOnPhotoActivity"
+            android:screenOrientation="portrait" />
+
+        <activity
+            android:name=".activities.TextOnImageActivity"
+            android:screenOrientation="portrait"
+            />
+        <activity
+            android:name=".activities.DrawOnBitmapActivity"
+            android:screenOrientation="portrait"
+             />
+
+
+        <activity
+            android:name=".activities.AddEffects"
+            android:label="Add Effect"
+            android:screenOrientation="portrait"
+            android:theme="@style/Theme.SmartPhotoEditor_action_bar"/>
+        <activity
+            android:name=".activities.AdjustImage"
+            android:label="Add Blur"
+            android:screenOrientation="portrait" />
+
+        <activity
+            android:name=".activities.ImageSavingActivity"
+            android:label="Final Step"
+            android:screenOrientation="portrait"
+            />
+
+
 
         <meta-data
             android:name="com.google.mlkit.vision.DEPENDENCIES"

app/src/main/java/com/app/smartphotoeditor/activities/AdjustImage.java

+package com.app.smartphotoeditor.activities;
+
+import android.app.ProgressDialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.os.AsyncTask;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.widget.ImageView;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.app.smartphotoeditor.R;
+import com.app.smartphotoeditor.asynctask.AddImageToArrayListAsyncTask;
+import com.app.smartphotoeditor.config.BlurUtils;
+import com.app.smartphotoeditor.config.ImageList;
+import com.app.smartphotoeditor.database.DatabaseHelper;
+import com.app.smartphotoeditor.listeners.OnAsyncTaskState;
+import com.app.smartphotoeditor.sdk.Methods;
+import com.bumptech.glide.Glide;
+import com.warkiz.tickseekbar.OnSeekChangeListener;
+import com.warkiz.tickseekbar.SeekParams;
+import com.warkiz.tickseekbar.TickSeekBar;
+
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Locale;
+
+
+public class AdjustImage extends AppCompatActivity implements OnAsyncTaskState {
+
+    private ImageView adjustImage;
+    private float blurValue = 0.0f;
+    private float saturationValue = 0.0f;
+    private float brightnessValue = 0.0f;
+
+    Bitmap currentEditingImage = null;
+
+    private ProgressDialog dialog;
+    private DatabaseHelper helper = new DatabaseHelper(AdjustImage.this);
+    private Methods methods;
+
+
+    @Override
+    protected void onStop() {
+        super.onStop();
+        if(dialog != null)
+        {
+            dialog.dismiss();
+        }
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        if(dialog != null)
+        {
+            dialog.dismiss();
+        }
+    }
+
+
+    @Override
+    protected void onDestroy()
+    {
+        super.onDestroy();
+    }
+
+
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.photo_on_photo_menu, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item)
+    {
+        if (item.getItemId() == R.id.setImage)
+        {
+
+                if(saturationValue > 0 || blurValue > 0 || brightnessValue > 0)
+                {
+                    dialog.setMessage("Loading..");
+                    dialog.setCancelable(false);
+                    dialog.show();
+                    AddImageToArrayListAsyncTask task = new AddImageToArrayListAsyncTask(currentEditingImage,this);
+                    task.execute();
+                }
+                else
+                {
+                    startActivityForResult();
+                }
+
+
+
+        }
+        return true;
+
+    }
+
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_adjust_image);
+
+
+
+
+
+        Methods.freeUpMemory();
+
+        methods = new Methods(getApplicationContext());
+        dialog = new ProgressDialog(AdjustImage.this);
+
+        adjustImage = findViewById(R.id.adjustImage);
+
+        TickSeekBar listener1 =  findViewById(R.id.listener);
+        TickSeekBar listener2 = findViewById(R.id.listener2);
+        TickSeekBar listener3 = findViewById(R.id.listener3);
+
+
+
+        createImage();
+
+
+        listener1.setOnSeekChangeListener(new OnSeekChangeListener()
+        {
+            @Override
+            public void onSeeking(SeekParams seekParams)
+            { }
+            @Override
+            public void onStartTrackingTouch(TickSeekBar seekBar) { }
+            @Override
+            public void onStopTrackingTouch(TickSeekBar seekBar)
+            {
+                blurValue = seekBar.getProgress();
+                createImage();
+            }
+
+        });
+
+        listener2.setOnSeekChangeListener(new OnSeekChangeListener() {
+            @Override
+            public void onSeeking(SeekParams seekParams)
+            { }
+            @Override
+            public void onStartTrackingTouch(TickSeekBar seekBar) { }
+            @Override
+            public void onStopTrackingTouch(TickSeekBar seekBar) {
+
+                saturationValue = seekBar.getProgress();
+                createImage();
+            }
+        });
+
+        listener3.setOnSeekChangeListener(new OnSeekChangeListener()
+        {
+            @Override
+            public void onSeeking(SeekParams seekParams)
+            { }
+            @Override
+            public void onStartTrackingTouch(TickSeekBar seekBar) { }
+            @Override
+            public void onStopTrackingTouch(TickSeekBar seekBar)
+            {
+                brightnessValue = seekBar.getProgress();
+                createImage();
+            }
+
+        });
+
+
+    }
+
+    private void createImage()
+    {
+
+        currentEditingImage = ImageList.getInstance().getCurrentBitmap().copy(ImageList.getInstance().getCurrentBitmap().getConfig(),true);
+        if(blurValue > 0)
+        {
+            currentEditingImage = new BlurUtils().blur(AdjustImage.this,currentEditingImage, blurValue);
+        }
+        if(saturationValue > 0)
+        {
+            currentEditingImage = methods.addSaturation(currentEditingImage,saturationValue);
+        }
+        if(brightnessValue > 0)
+        {
+            currentEditingImage = methods.changeBitmapContrastBrightness(currentEditingImage,1f,brightnessValue);
+        }
+
+
+        Glide.with(getApplicationContext()).load(currentEditingImage).into(adjustImage);
+    }
+
+    @Override
+    public void startActivityForResult()
+    {
+        dialog.hide();
+        dialog.cancel();
+
+        if(saturationValue > 0 || blurValue > 0 || brightnessValue > 0)
+        {
+            AsyncTask.execute(new Runnable()
+            {
+                @Override
+                public void run()
+                {
+                    //get Date and time
+                    SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd \nHH:mm:ss", Locale.getDefault());
+                    String currentDateandTime = sdf.format(new Date());
+
+                    String path = Methods.saveToInternalStorage(getApplicationContext(),ImageList.getInstance().getCurrentBitmap(),currentDateandTime);
+
+                    if(helper.AddImage(null,path))
+                        ImageList.getInstance().deleteUndoRedoImages();
+
+
+                }
+            });
+        }
+
+        Intent intent = new Intent();
+        setResult(11,intent);
+        finish();
+    }
+}

app/src/main/java/com/app/smartphotoeditor/activities/DenoisingActivity.java

@@ -67,7 +67,7 @@ public class DenoisingActivity extends AppCompatActivity {
         }
 
         //applying auto denoising filter to the image ----------
-        autoDenoisImage();
+        //autoDenoisImage();
 
         denoiseBar.setOnSeekBarChangeListener(new SeekBar.OnSeekBarChangeListener() {
             @Override

app/src/main/java/com/app/smartphotoeditor/activities/ImageSavingActivity.java

+package com.app.smartphotoeditor.activities;
+
+import android.app.Dialog;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.content.res.Configuration;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.graphics.Typeface;
+import android.graphics.drawable.ColorDrawable;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Bundle;
+import android.provider.MediaStore;
+import android.view.View;
+import android.widget.Button;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+
+import androidx.appcompat.app.AppCompatActivity;
+
+import com.app.smartphotoeditor.R;
+import com.app.smartphotoeditor.config.ImageList;
+import com.app.smartphotoeditor.sdk.Methods;
+import com.bumptech.glide.Glide;
+import com.google.android.material.imageview.ShapeableImageView;
+
+import java.io.ByteArrayOutputStream;
+import java.util.Locale;
+
+
+public class ImageSavingActivity extends AppCompatActivity {
+
+
+    private Methods methods;
+
+
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_image_saving);
+
+        methods = new Methods(ImageSavingActivity.this);
+
+
+
+        ImageView saveFinalImage = (ImageView) findViewById(R.id.saveFinalImage);
+        ShapeableImageView userSavingImage = (ShapeableImageView) findViewById(R.id.userSavingImage);
+
+        TextView fromGalery = findViewById(R.id.fromGalery);
+
+        ImageView shareImageView = findViewById(R.id.shareImageView);
+
+        ImageView downloadImageView = findViewById(R.id.downloadImageView);
+
+        TextView downloadImageText = findViewById(R.id.downloadImageText);
+
+
+
+        shareImageView.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v)
+            {
+                try
+                {
+                    shareImageUri(getImageUri(getApplicationContext(), ImageList.getInstance().getCurrentBitmap()));
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        fromGalery.setOnClickListener(new View.OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+                try
+                {
+                    shareImageUri(getImageUri(getApplicationContext(),ImageList.getInstance().getCurrentBitmap()));
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                }
+            }
+        });
+
+        downloadImageView.setOnClickListener(new View.OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+               showDialog();
+            }
+        });
+
+        downloadImageText.setOnClickListener(new View.OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+                showDialog();
+            }
+        });
+
+
+        ImageView shareFinalImage = (ImageView) findViewById(R.id.shareFinalImage);
+
+        shareFinalImage.setOnClickListener(new View.OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+                try
+                {
+                    shareImageUri(getImageUri(getApplicationContext(),ImageList.getInstance().getCurrentBitmap()));
+                }
+                catch (Exception e)
+                {
+                    e.printStackTrace();
+                }
+
+            }
+        });
+
+
+
+        Glide.with(getApplicationContext()).load(ImageList.getInstance().getCurrentBitmap()).into(userSavingImage);
+
+
+
+
+
+        saveFinalImage.setOnClickListener(new View.OnClickListener()
+        {
+            @Override
+            public void onClick(View v)
+            {
+                showDialog();
+
+            }
+        });
+
+
+    }
+
+    private void showDialog()
+    {
+        final Dialog dialog = new Dialog(ImageSavingActivity.this);
+        if(dialog.getWindow() != null)
+        {
+            dialog.getWindow().setBackgroundDrawable(new ColorDrawable(Color.TRANSPARENT));
+            // dialog.getWindow().setDimAmount(0.4f);
+            float deviceWidth = Methods.getDeviceWidthInPX(getApplicationContext());
+            int finalWidth = (int) (deviceWidth - (deviceWidth / 8));
+            dialog.getWindow().setLayout(finalWidth,RelativeLayout.LayoutParams.WRAP_CONTENT);
+        }
+
+        View view = getLayoutInflater().inflate(R.layout.exit_dialog_layout,null);
+        dialog.setContentView(view);
+
+
+
+        TextView message = view.findViewById(R.id.textView8);
+
+        message.setText(getResources().getString(R.string.rate_app_description));
+
+
+        TextView title = view.findViewById(R.id.textView7);
+
+
+        ImageView imageView6 = view.findViewById(R.id.imageView6);
+        imageView6.setImageDrawable(getDrawable(R.drawable.download_image_cartoon));
+
+        title.setText(getResources().getString(R.string.rate_app_text));
+
+
+        Button yes = view.findViewById(R.id.yesButton);
+        Button no = view.findViewById(R.id.noButton);
+
+        yes.setText(getResources().getString(R.string.okay_text));
+        no.setText(getResources().getString(R.string.cannot_text));
+
+        yes.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v)
+            {
+//                dialog.dismiss();
+//                methods.SaveImage(ImageList.getInstance().getCurrentBitmap(),getContentResolver());
+//                startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse(APP_MARKET_LINK)));
+
+            }
+        });
+
+
+        no.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v)
+            {
+                dialog.dismiss();
+                methods.SaveImage(ImageList.getInstance().getCurrentBitmap(),getContentResolver());
+
+            }
+        });
+        dialog.show();
+    }
+
+    private void shareImageUri(Uri uri)
+    {
+        if(uri != null)
+        {
+            Intent intent = new Intent(Intent.ACTION_SEND);
+            intent.putExtra(Intent.EXTRA_STREAM, uri);
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+            intent.setType("image/png");
+            startActivity(intent);
+        }
+
+    }
+    public Uri getImageUri(Context inContext, Bitmap inImage)
+    {
+        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+        inImage.compress(Bitmap.CompressFormat.PNG, 100, bytes);
+        String path = MediaStore.Images.Media.insertImage(inContext.getContentResolver(), inImage, "Title", null);
+
+        return Uri.parse(path);
+    }
+}

app/src/main/java/com/app/smartphotoeditor/activities/MyGallery.java

@@ -28,6 +28,7 @@ import androidx.recyclerview.widget.RecyclerView;
 import com.airbnb.lottie.LottieAnimationView;
 import com.app.smartphotoeditor.R;
 import com.app.smartphotoeditor.adapters.ImageAdapter;
+import com.app.smartphotoeditor.config.ImageList;
 import com.app.smartphotoeditor.listeners.OnAlbumClick;
 import com.app.smartphotoeditor.listeners.OnCameraPreviewChanged;
 import com.app.smartphotoeditor.listeners.ml.OnEyeStatusChanged;
@@ -185,7 +186,7 @@ public class MyGallery extends AppCompatActivity {
                                         @Override
                                         public void run()
                                         {
-                                            imageAdapter.scrollRight();
+                                            imageAdapter.scrollLeft();
                                         }
                                     });
                                 }
@@ -197,7 +198,7 @@ public class MyGallery extends AppCompatActivity {
                                         @Override
                                         public void run()
                                         {
-                                            imageAdapter.scrollLeft();
+                                            imageAdapter.scrollRight();
                                         }
                                     });
                                 }
@@ -512,10 +513,13 @@ public class MyGallery extends AppCompatActivity {
                     if(selectedBitmap != null)
                     {
 
-                        Intent intent = new Intent(MyGallery.this, CropActivity.class);
-                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
+                        ImageList.getInstance().clearImageList();
+                        ImageList.getInstance().addBitmap(selectedBitmap,true);
+
+                        Intent intent = new Intent(MyGallery.this, EditorActivity.class);
+//                        intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK | Intent.FLAG_ACTIVITY_NEW_TASK);
                         startActivity(intent);
-                        finish();
+//                        finish();
 
 
                     }
@@ -534,7 +538,7 @@ public class MyGallery extends AppCompatActivity {
                     isStillShowing = false;
                     select_image_layout.animate().setDuration(500).translationYBy(0).translationY(200).start();
                 }
-            },7000);
+            },3000);
 
         }
 

app/src/main/java/com/app/smartphotoeditor/adapters/FilterAdapter.java

+package com.app.smartphotoeditor.adapters;
+
+import android.app.Activity;
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.graphics.Color;
+import android.os.AsyncTask;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ProgressBar;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.app.smartphotoeditor.R;
+import com.app.smartphotoeditor.config.ImageList;
+import com.app.smartphotoeditor.listeners.OnBitmapChanged;
+import com.app.smartphotoeditor.sdk.Methods;
+import com.bumptech.glide.Glide;
+import com.zomato.photofilters.imageprocessors.Filter;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Set;
+
+import de.hdodenhof.circleimageview.CircleImageView;
+
+public class FilterAdapter extends RecyclerView.Adapter<FilterAdapter.FilterViewHolder>
+{
+    private Context context;
+    private List<Filter> filters;
+    private int previousPosition = -99;
+    private OnBitmapChanged listner;
+    private Bitmap currentBitmap = null;
+
+    private HashMap<Integer,CircleImageView> circleImageList;
+    private Bitmap croppedBitmap = null;
+    private ProgressBar progressBar;
+
+    private int selectedFilter = -1;
+    private HashMap<Integer,View> filterList = new HashMap<>();
+
+    public FilterAdapter(Context context, List<Filter> filters, OnBitmapChanged listner,ProgressBar progressBar)
+    {
+        this.context = context;
+        this.filters = filters;
+        this.listner = listner;
+        circleImageList = new HashMap<>();
+        this.progressBar = progressBar;
+
+    }
+    @NonNull
+    @Override
+    public FilterViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType)
+    {
+        View view = LayoutInflater.from(context).inflate(R.layout.filter_row,null);
+        return new FilterViewHolder(view);
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull final FilterViewHolder holder, final int position)
+    {
+        if(filters != null)
+        {
+
+
+
+
+            AsyncTask.execute(new Runnable() {
+                @Override
+                public void run()
+                {
+
+                    if(croppedBitmap == null)
+                    {
+                        croppedBitmap = Methods.resize(ImageList.getInstance().getCurrentBitmap(),100,100);
+                    }
+
+                    Bitmap bitmap = croppedBitmap.copy(croppedBitmap.getConfig(),true);
+                    final Bitmap filtered = filters.get(position).processFilter(bitmap);
+
+                    ((Activity)context).runOnUiThread(new Runnable() {
+                        @Override
+                        public void run()
+                        {
+                            Glide.with(context).load(filtered).into(holder.previewImage);
+                        }
+                    });
+
+                }
+            });
+
+
+            String name= filters.get(position).getName();
+            if(name != null)
+            {
+                holder.filterName.setText(name);
+            }
+
+
+            holder.itemView.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    if(previousPosition != position)
+                    {
+                        if(progressBar != null)
+                        {
+                            progressBar.setVisibility(View.VISIBLE);
+                        }
+                        AsyncTask.execute(new Runnable() {
+                            @Override
+                            public void run()
+                            {
+                                currentBitmap = ImageList.getInstance().getCurrentBitmap().copy(ImageList.getInstance().getCurrentBitmap().getConfig(),true);
+                                Bitmap largeBitmap = filters.get(position).processFilter(currentBitmap);
+                                listner.bitmapChanged(largeBitmap,filters.get(position));
+                            }
+                        });
+
+                        previousPosition = position;
+
+
+                        Set<Integer> keys = circleImageList.keySet();
+                        for(Integer key : keys)
+                        {
+                            if(position == key)
+                            {
+                                circleImageList.get(key).setAlpha(1f);
+                                circleImageList.get(key).setBorderWidth(4);
+                                circleImageList.get(key).setBorderColor(Color.WHITE);
+
+                                circleImageList.get(key).animate().scaleX(1.08f).scaleY(1.08f).start();
+                            }
+                            else
+                            {
+                                circleImageList.get(key).animate().scaleX(1f).scaleY(1f).start();
+                                circleImageList.get(key).setAlpha(0.7f);
+                                circleImageList.get(key).setBorderWidth(2);
+                                circleImageList.get(key).setBorderColor(Color.WHITE);
+                            }
+                        }
+
+
+                    }
+
+
+                }
+            });
+        }
+
+        circleImageList.put(position,holder.previewImage);
+        filterList.put(position,holder.itemView);
+
+
+    }
+
+
+    @Override
+    public int getItemCount()
+    {
+        if(filters != null)
+        {
+            return filters.size();
+        }
+        return 0;
+
+    }
+
+    public class FilterViewHolder extends RecyclerView.ViewHolder
+    {
+
+        CircleImageView previewImage;
+        TextView filterName;
+
+        public FilterViewHolder(@NonNull View itemView)
+        {
+            super(itemView);
+            previewImage = itemView.findViewById(R.id.filter_preview);
+            filterName = itemView.findViewById(R.id.filter_name);
+        }
+    }
+    public void scrollRight()
+    {
+        selectedFilter++;
+        Set<Integer> keySet = filterList.keySet();
+        for(Integer key : keySet)
+        {
+            if(key == selectedFilter)
+            {
+                View view = filterList.get(key);
+                view.performClick();
+                break;
+            }
+        }
+    }
+    public void scrollLeft()
+    {
+        if(selectedFilter == -1) return;
+
+        selectedFilter--;
+        Set<Integer> keySet = filterList.keySet();
+        for(Integer key : keySet)
+        {
+            if(key == selectedFilter)
+            {
+                View view = filterList.get(key);
+                view.performClick();
+                break;
+            }
+        }
+    }
+}

app/src/main/java/com/app/smartphotoeditor/adapters/GridViewAdapter.java

+package com.app.smartphotoeditor.adapters;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+import androidx.constraintlayout.widget.ConstraintLayout;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.app.smartphotoeditor.R;
+import com.app.smartphotoeditor.activities.MyGallery;
+import com.app.smartphotoeditor.listeners.OnItemClickListner;
+import com.app.smartphotoeditor.models.GalleryImage;
+import com.app.smartphotoeditor.sdk.Methods;
+import com.bumptech.glide.Glide;
+
+import java.io.File;
+import java.util.ArrayList;
+
+public class GridViewAdapter extends RecyclerView.Adapter<GridViewAdapter.MyViewHolder>
+{
+    private Context context;
+    private ArrayList<GalleryImage> images;
+    public static final int numberOfImagesInARow = 3;
+    private OnItemClickListner listner;
+
+    public GridViewAdapter(Context context, ArrayList<GalleryImage> images, OnItemClickListner listner)
+    {
+        this.context = context;
+        this.images = images;
+        this.listner = listner;
+    }
+    public void setContext(Context context)
+    {
+        this.context = context;
+    }
+
+    @NonNull
+    @Override
+    public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType)
+    {
+       View view = LayoutInflater.from(context).inflate(R.layout.custom_gallery_row, parent, false);
+       view.setLayoutParams(new ConstraintLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, (int) (Methods.getDeviceHeightInPX(context) / 5)));
+       return new MyViewHolder(view);
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull MyViewHolder holder, final int position)
+    {
+
+
+        if(images.size() > (position * numberOfImagesInARow) && images.get(position * numberOfImagesInARow).getFile() != null)
+        {
+
+                Glide.with(context)
+                    .load(images.get(position * numberOfImagesInARow).getFile())
+                    .placeholder(R.drawable.loading_image_placeholder)
+                    .error(R.drawable.loading_image_placeholder)
+                    .into(holder.imgView);
+
+            holder.imgView.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    showSelectView(images.get(position * numberOfImagesInARow).getFile());
+                }
+            });
+        }
+        else
+        {
+            holder.imgView.setImageBitmap(null);
+            holder.imgView.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    showSelectView(null);
+                }
+            });
+        }
+        if(images.size() > ((position * numberOfImagesInARow) + 1) && images.get(((position * numberOfImagesInARow) + 1)).getFile() != null)
+        {
+            Glide.with(context)
+                    .load(images.get(((position * numberOfImagesInARow) + 1)).getFile())
+                    .placeholder(R.drawable.loading_image_placeholder)
+                    .error(R.drawable.loading_image_placeholder)
+                    .into(holder.imgView2);
+
+            holder.imgView2.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    showSelectView(images.get(((position * numberOfImagesInARow) + 1)).getFile());
+                }
+            });
+        }
+        else
+        {
+            holder.imgView2.setImageBitmap(null);
+            holder.imgView2.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    showSelectView(null);
+                }
+            });
+        }
+        if(images.size() > ((position * numberOfImagesInARow) + 2) && images.get(((position * numberOfImagesInARow) + 2)).getFile() != null)
+        {
+            Glide.with(context)
+                    .load(images.get(((position * numberOfImagesInARow) + 2)).getFile())
+                    .placeholder(R.drawable.loading_image_placeholder)
+                    .error(R.drawable.loading_image_placeholder)
+                    .into(holder.imgView3);
+
+            holder.imgView3.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    showSelectView(images.get(((position * numberOfImagesInARow) + 2)).getFile());
+                }
+            });
+        }
+        else
+        {
+            holder.imgView3.setImageBitmap(null);
+            holder.imgView3.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    showSelectView(null);
+                }
+            });
+        }
+
+    }
+
+    @Override
+    public int getItemCount()
+    {
+
+        if(images.size() % numberOfImagesInARow == 0)
+        {
+            return (images.size() / numberOfImagesInARow);
+        }
+        else
+        {
+            return (images.size() / numberOfImagesInARow) + 1;
+        }
+
+    }
+
+    public class MyViewHolder extends RecyclerView.ViewHolder
+    {
+        private ImageView imgView;
+        private ImageView imgView2;
+        private ImageView imgView3;
+
+        public MyViewHolder(@NonNull View itemView)
+        {
+            super(itemView);
+            imgView = itemView.findViewById(R.id.image);
+            imgView2 = itemView.findViewById(R.id.image2);
+            imgView3 = itemView.findViewById(R.id.image3);
+        }
+    }
+    private void showSelectView(File file)
+    {
+        if(file == null)
+        {
+            return;
+        }
+        listner.onClicked(file);
+        MyGallery.selectedBitmap = Methods.getBitmap(file.getAbsolutePath());
+    }
+}

app/src/main/java/com/app/smartphotoeditor/adapters/ImageViewPlusColorAdapter.java

+package com.app.smartphotoeditor.adapters;
+
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.drawable.ColorDrawable;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+
+import com.app.smartphotoeditor.R;
+import com.app.smartphotoeditor.custom.ImageViewPlus;
+import com.app.smartphotoeditor.listeners.OnTextAttributesChangedListner;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import de.hdodenhof.circleimageview.CircleImageView;
+
+public class ImageViewPlusColorAdapter extends RecyclerView.Adapter<ImageViewPlusColorAdapter.MyViewHolder>
+{
+    private Context context;
+    private ArrayList<Integer> colorList;
+    private OnTextAttributesChangedListner listner;
+    private HashMap<Integer, ImageView> viewList;
+    private ImageViewPlus selectedImageView;
+
+    public ImageViewPlusColorAdapter(Context context, ImageViewPlus selectedImageView, OnTextAttributesChangedListner listner)
+    {
+        this.context = context;
+        this.listner = listner;
+        this.selectedImageView = selectedImageView;
+        colorList = new ArrayList<>();
+        viewList = new HashMap<Integer, ImageView>();
+        setColorsList();
+    }
+
+    @NonNull
+    @Override
+    public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType)
+    {
+        View view = LayoutInflater.from(context).inflate(R.layout.text_color_row,null,false);
+        return new MyViewHolder(view);
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull MyViewHolder holder, final int position)
+    {
+        if(colorList != null && colorList.size() > position)
+        {
+            viewList.put(position,holder.is_selected);
+            holder.color_lay.setClipToOutline(true);
+            ColorDrawable colorDrawable = new ColorDrawable(colorList.get(position));
+            holder.color_lay.setImageDrawable(colorDrawable);
+            holder.color_lay.setImageDrawable(colorDrawable);
+
+            if(selectedImageView != null)
+            {
+                if(selectedImageView.getBorderColor() == colorList.get(position))
+                {
+                    ImageView view  = viewList.get(position);
+                    if(view != null)
+                    {
+                        view.setVisibility(View.VISIBLE);
+                    }
+                }
+            }
+
+            holder.itemView.setOnClickListener(new View.OnClickListener() {
+                @Override
+                public void onClick(View v) {
+
+                    listner.onTextColorChanged(colorList.get(position));
+
+                    ArrayList<Integer> keyList = new ArrayList<>(viewList.keySet());
+                    for(int i = 0; i < keyList.size(); i++)
+                    {
+                        if(position == keyList.get(i))
+                        {
+                            if (viewList.get(keyList.get(i)) != null)
+                            {
+                                ImageView view = viewList.get(keyList.get(i));
+                                if (view != null)
+                                {
+                                    view.setVisibility(View.VISIBLE);
+                                }
+
+                            }
+                        }
+                        else
+                        {
+                            ImageView view = viewList.get(keyList.get(i));
+                            if(view != null)
+                            {
+                                view.setVisibility(View.GONE);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+
+    }
+
+    @Override
+    public int getItemCount()
+    {
+        return colorList.size();
+    }
+
+    public class MyViewHolder extends RecyclerView.ViewHolder
+    {
+        CircleImageView color_lay;
+        ImageView is_selected;
+        private MyViewHolder(@NonNull View itemView)
+        {
+            super(itemView);
+            color_lay = itemView.findViewById(R.id.color_lay);
+            is_selected = itemView.findViewById(R.id.is_selected);
+        }
+    }
+    private void setColorsList()
+    {
+
+        colorList.add(Color.BLACK);
+        colorList.add(Color.WHITE);
+        colorList.add(Color.GRAY);
+        colorList.add(Color.LTGRAY);
+        colorList.add(Color.RED);
+        colorList.add(Color.GREEN);
+        colorList.add(Color.BLUE);
+        colorList.add(Color.DKGRAY);
+        colorList.add(Color.YELLOW);
+        colorList.add(Color.CYAN);
+        colorList.add(Color.MAGENTA);
+
+        if(selectedImageView != null)
+        {
+
+            for(int i = 0; i < colorList.size(); i++)
+            {
+                if(colorList.get(i) == selectedImageView.getBorderColor())
+                {
+                    colorList.remove(i);
+                    colorList.add(0,selectedImageView.getBorderColor());
+                    notifyDataSetChanged();
+                    break;
+                }
+            }
+        }
+
+    }
+}

app/src/main/java/com/app/smartphotoeditor/adapters/StickerAdapter.java

+package com.app.smartphotoeditor.adapters;
+
+import android.content.Context;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import androidx.annotation.NonNull;
+import androidx.recyclerview.widget.RecyclerView;
+
+import com.app.smartphotoeditor.R;
+import com.bumptech.glide.Glide;
+
+import java.util.ArrayList;
+
+public class StickerAdapter extends RecyclerView.Adapter<StickerAdapter.MyViewHolder>
+{
+    private ArrayList<String> imageList;
+    private Context context;
+    public StickerAdapter(Context context,ArrayList<String> imageList)
+    {
+        this.context = context;
+        this.imageList = imageList;
+    }
+
+    @NonNull
+    @Override
+    public MyViewHolder onCreateViewHolder(@NonNull ViewGroup parent, int viewType)
+    {
+        View view = LayoutInflater.from(context).inflate(R.layout.sticker_row,null);
+        return new MyViewHolder(view);
+    }
+
+    @Override
+    public void onBindViewHolder(@NonNull MyViewHolder holder, int position)
+    {
+        if(imageList != null && imageList.size() > position)
+        {
+            Glide.with(context).load(imageList.get(position)).into(holder.sticker);
+        }
+    }
+
+    @Override
+    public int getItemCount()
+    {
+        if(imageList != null)
+            return imageList.size();
+        else
+            return 0;
+    }
+
+    public class MyViewHolder extends RecyclerView.ViewHolder
+    {
+        ImageView sticker;
+        public MyViewHolder(@NonNull View itemView)
+        {
+            super(itemView);
+            sticker = itemView.findViewById(R.id.sticker);
+        }
+    }
+}

app/src/main/java/com/app/smartphotoeditor/listeners/OnAsyncTaskState.java

+package com.app.smartphotoeditor.listeners;
+
+public interface OnAsyncTaskState
+{
+    public void startActivityForResult();
+}