package [Link].

ui;

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link].R;
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];
import [Link];

public class EasyPaint extends AppCompatActivity implements [Link],

[Link], [Link], ColorPickerDialogListener {

Button btn_ok;
List<Integer> selectedIcon = new ArrayList<>();
List<ToolsModle> toolsModles = new ArrayList<>();
List<LinearLayout> parentLayoutList = new ArrayList<>();
LinearLayout infoView, toolsLayout, clear_layout, layout_add_text,
layout_pencil, layout_magic_brush, layout_brush_setting, layout_brush;
IndicatorSeekBar brush_eraser_size, brush_smoothness, brush_brush_size;
ImageView btn_magic_back, btn_zoom, btn_cleaner_back, btn_color,
btn_add_text_back, btn_brush_back, btn_pencil_back, btn_brush_setting;
int textColor, brush_color_pos, pencil_color_pos, brushColor = [Link],
pencilColor = [Link], brush_smooth_size = 0, brush_size = 15, brush_erase_size =
10, pencil_erase_size;
RecyclerView rec_magic, rec_brush_color, rec_pencil_color, rec_font;
public static int RequestPermissionCode = 1;
boolean isPencil = false, isPaintSelected = false;
ImageButton btn_refresh, btn_back, btn_redo, btn_undo, btn_clear, btn_save,
btn_brush, btn_magic_brush, btn_pencil, btn_sticker, btn_add_text;
List<ImageView> headerList;
boolean isZoomClick, isToolsLayoutVisible = true;
int REQUEST_STICKER = 111;
MagicAdapter magicAdapter;
String[] font_file_list;
String[] magic_pattern_list;
TextStickerView mCurrentEditTextView;
FontStyleAdapter fontStyleAdapter;
List<String> colorsList;
ConnectionDetector cd;
int action = -1;
ArrayList<String> stickerlist = new ArrayList<>();
ColorAdapter colorAdapter, pencilColorAdapter;
FrameLayout backgroundLayout;
boolean isOfflineMode;
RelativeLayout bottom_layout, header, top_layout, zoomView;
String imageName, category_name, category_id, savePath, textString, font,
magicBrush;
ArrayList<StickerView> bitmapstickerList = new ArrayList<>();
ArrayList<TextStickerView> textStickerViews = new ArrayList<>();
public ArrayList<View> mViews = new ArrayList<>();
StickerView mCurrentView;
 ImageView imageView;
DrawingArea paintView;

@Override
protected void onResume() {
[Link]();
cd = new ConnectionDetector(this);
}

private void getFontFileList() {

AssetManager assetManager = getResources().getAssets();
font_file_list = new String[0];

try {
String newfonts = "font";
font_file_list = [Link](newfonts);
} catch (IOException e) {
[Link]();
}
assert font_file_list != null;
font = font_file_list[0];

private void getMagicPatternList() {

AssetManager assetManager = getResources().getAssets();
magic_pattern_list = new String[0];

try {
String newfonts = "magicbrush";
magic_pattern_list = [Link](newfonts);
} catch (IOException e) {
[Link]();
}
assert magic_pattern_list != null;
magicBrush = magic_pattern_list[0];

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {

[Link](savedInstanceState);setContentView([Link].activity_easy_paint);
init();
setListener();
}

private void setListener() {

brush_brush_size.setOnSeekChangeListener(new OnSeekChangeListener() {
@Override
public void onSeeking(SeekParams seekParams) {

brush_size = [Link];
[Link]([Link]);

}
 @Override
public void onStartTrackingTouch(IndicatorSeekBar seekBar) {

@Override
public void onStopTrackingTouch(IndicatorSeekBar seekBar) {

}
});

brush_smoothness.setOnSeekChangeListener(new OnSeekChangeListener() {
@Override
public void onSeeking(SeekParams seekParams) {
brush_smooth_size = [Link];
[Link](brush_smooth_size);

@Override
public void onStartTrackingTouch(IndicatorSeekBar seekBar) {

@Override
public void onStopTrackingTouch(IndicatorSeekBar seekBar) {

}
});

brush_eraser_size.setOnSeekChangeListener(new OnSeekChangeListener() {
@Override
public void onSeeking(SeekParams seekParams) {
if (isPencil) {
pencil_erase_size = [Link];
} else {
brush_erase_size = [Link];
}

[Link]([Link]);
}

@Override
public void onStartTrackingTouch(IndicatorSeekBar seekBar) {

@Override
public void onStopTrackingTouch(IndicatorSeekBar seekBar) {

}
});

}
 // Exit Page Dialog
public void showExitDialog() {
[Link] builder = new
[Link](this, [Link]);
[Link](getString([Link].exit_text));
[Link](false);
[Link](getString([Link]), (dialogInterface, i) ->
{
finish();

});
[Link](getString([Link]), (dialogInterface, i) ->
[Link]());
[Link] alertDialog = [Link]();
[Link]();
}

@Override
public void onBackPressed() {
showExitDialog();
}

@SuppressLint("ClickableViewAccessibility")
private void init() {
headerList = new ArrayList<>();
colorsList = new ArrayList<>();
colorsList = [Link]();
imageName = getIntent().getStringExtra([Link]);
category_id = getIntent().getStringExtra(Constants.CATEGORY_ID);
category_name = getIntent().getStringExtra(Constants.CATEGORY_NAME);
isOfflineMode = getIntent().getBooleanExtra([Link],
false);

rec_magic = findViewById([Link].rec_magic);
layout_brush = findViewById([Link].layout_brush);
btn_brush_back = findViewById([Link].btn_brush_back);
btn_add_text_back = findViewById([Link].btn_add_text_back);
btn_pencil_back = findViewById([Link].btn_pencil_back);
btn_brush_setting = findViewById([Link].btn_brush_setting);
rec_brush_color = findViewById([Link].rec_brush_color);
rec_pencil_color = findViewById([Link].rec_pencil_color);
rec_font = findViewById([Link].rec_font);
layout_brush_setting = findViewById([Link].layout_brush_setting);
brush_smoothness = findViewById([Link].brush_smoothness);
brush_brush_size = findViewById([Link].brush_brush_size);
backgroundLayout = findViewById([Link]);
layout_pencil = findViewById([Link].layout_pencil);
layout_magic_brush = findViewById([Link].layout_magic_brush);
clear_layout = findViewById([Link].clear_layout);
brush_eraser_size = findViewById([Link].brush_eraser_size);
layout_add_text = findViewById([Link].layout_add_text);
btn_color = findViewById([Link].btn_color);
btn_cleaner_back = findViewById([Link].btn_cleaner_back);
bottom_layout = findViewById([Link].bottom_layout);
header = findViewById([Link]);
infoView = findViewById([Link]);
btn_zoom = findViewById([Link].btn_zoom);
btn_back = findViewById([Link].btn_back);
btn_magic_back = findViewById([Link].btn_magic_back);
btn_redo = findViewById([Link].btn_redo);
btn_undo = findViewById([Link].btn_undo);
btn_clear = findViewById([Link].btn_clear);
btn_refresh = findViewById([Link].btn_refresh);
btn_save = findViewById([Link].btn_save);
btn_brush = findViewById([Link].btn_brush);
btn_magic_brush = findViewById([Link].btn_magic_brush);
btn_pencil = findViewById([Link].btn_pencil);
btn_sticker = findViewById([Link].btn_sticker);
btn_add_text = findViewById([Link].btn_add_text);
toolsLayout = findViewById([Link]);
top_layout = findViewById([Link].top_layout);
zoomView = findViewById([Link]);
btn_ok = findViewById([Link].btn_ok);
imageView = findViewById([Link]);
paintView = findViewById([Link]);
brush_brush_size.setMin(15);

toolsModles = [Link](getApplicationContext());
selectedIcon = [Link]();

[Link](btn_redo);
[Link](btn_undo);
[Link](btn_clear);
[Link](btn_brush);
[Link](btn_magic_brush);
[Link](btn_pencil);

setClick(btn_back);
setClick(btn_redo);
setClick(btn_undo);
setClick(btn_clear);
setClick(btn_refresh);
setClick(btn_save);
setClick(btn_brush);
setClick(btn_magic_brush);
setClick(btn_pencil);
setClick(btn_sticker);
setClick(btn_add_text);
setClick(btn_brush_back);
setClick(btn_pencil_back);
setClick(btn_brush_setting);
setClick(layout_pencil);
setClick(layout_magic_brush);
setClick(btn_magic_back);
setClick(btn_add_text_back);
setClick(btn_color);
setClick(btn_cleaner_back);
setClick(btn_zoom);
setClick(btn_ok);
getFontFileList();
getMagicPatternList();
setRecyclerBrushColor();
setRecyclerPencilColor();
setRecyclerFontStyle();
setRecyclerMagic();
setDrawView();
 textString = "Text Sticker";
setUnselectImage();

[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]([Link] - 1).unSelectedIcon));
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]([Link] - 1).unSelectedIcon));

// enableDisableUndo();
[Link]((view, motionEvent) -> {
setCurrentEditFalse();
setCurrentTextFalse();
return true;
});

[Link](clear_layout);
[Link](layout_add_text);
[Link](layout_pencil);
[Link](layout_brush_setting);
[Link](layout_brush);
[Link](layout_magic_brush);

public void setRecyclerBrushColor() {

colorAdapter = new ColorAdapter(colorsList, getApplicationContext(), true);
rec_brush_color.setLayoutManager(new
LinearLayoutManager(getApplicationContext(), [Link],
false));
rec_brush_color.setAdapter(colorAdapter);
[Link](this);
}

public void setUnselectImage() {

for (int i = 0; i < [Link](); i++) {

[Link](i).setImageDrawable([Link](getApplicationContext(
), [Link](i).icon));

}
}

public void setRecyclerPencilColor() {

pencilColorAdapter = new ColorAdapter(colorsList, getApplicationContext(),
false);
rec_pencil_color.setLayoutManager(new
LinearLayoutManager(getApplicationContext(), [Link],
false));
rec_pencil_color.setAdapter(pencilColorAdapter);
[Link](this);
}

public void setRecyclerFontStyle() {

 rec_font.setLayoutManager(new LinearLayoutManager(getApplicationContext(),
[Link], false));

fontStyleAdapter = new FontStyleAdapter(getApplicationContext(),

font_file_list, (v, pos) -> {
font = font_file_list[pos];

if (mCurrentEditTextView != null) {
[Link](getApplicationContext(),
font);
}

[Link](pos);
});
rec_font.setAdapter(fontStyleAdapter);

public void setRecyclerMagic() {

rec_magic.setLayoutManager(new LinearLayoutManager(getApplicationContext(),
[Link], false));

magicAdapter = new MagicAdapter([Link](magic_pattern_list),

getApplicationContext(), (view, i, s) -> {

magicBrush = s;

Log.e("magicBrush", "" + magicBrush);

[Link](magicBrush);
});
rec_magic.setAdapter(magicAdapter);

public void setDrawView() {

[Link] options = new [Link]();
[Link] = [Link].ALPHA_8;
DisplayMetrics displayMetrics = new DisplayMetrics();
getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
int width = [Link];
width = width - 20;

final Bitmap[] originalBitmap = {null};

cd = new ConnectionDetector(this);
if (!isOfflineMode) {
if ([Link]()) {

int finalWidth = width;

[Link](this)
.asBitmap()
.load(imageName)
.skipMemoryCache(true)
.into(new CustomTarget<Bitmap>() {
@Override
 public void onResourceReady(@NonNull Bitmap resource,
@Nullable Transition<? super Bitmap> transition) {

Log.e("resource", "" + resource);

originalBitmap[0] = scaleBitmap(resource,
finalWidth, finalWidth);

[Link](originalBitmap[0]);

[Link] layoutParams = new

[Link](originalBitmap[0].getWidth(),
originalBitmap[0].getHeight());
[Link] = [Link];
[Link](layoutParams);

@Override
public void onLoadCleared(@Nullable Drawable
placeholder) {
}
});

[Link]([Link]);
[Link](magicBrush);
} else {
originalBitmap[0] =
scaleBitmap([Link](imageName), width, width);
[Link](originalBitmap[0]);
[Link] layoutParams = new
[Link](originalBitmap[0].getWidth(),
originalBitmap[0].getHeight());
[Link] = [Link];
[Link](layoutParams);
}

} else {

originalBitmap[0] = scaleBitmap([Link](imageName),
width, width);
[Link](originalBitmap[0]);
[Link] layoutParams = new
[Link](originalBitmap[0].getWidth(),
originalBitmap[0].getHeight());
[Link] = [Link];
[Link](layoutParams);

public Bitmap scaleBitmap(Bitmap bitmap, int newWidth, int newHeight) {

Bitmap scaledBitmap = [Link](newWidth, newHeight,
[Link].ARGB_8888);
 float scaleX = newWidth / (float) [Link]();
float scaleY = newHeight / (float) [Link]();
float pivotX = 0;
float pivotY = 0;

Matrix scaleMatrix = new Matrix();

[Link](scaleX, scaleY, pivotX, pivotY);

Canvas canvas = new Canvas(scaledBitmap);

[Link](scaleMatrix);
[Link](bitmap, 0, 0, new Paint(Paint.FILTER_BITMAP_FLAG));

return scaledBitmap;
}

public void setBackgroundView() {

[Link](true);
}

public void goneAllLayout() {

for (int i = 0; i < [Link](); i++) {
[Link](i).setVisibility([Link]);
}
}

public void visibleActionLayout() {

if (action != -1) {
if (action == 3) {
[Link](4).setVisibility([Link]);
[Link](action).setVisibility([Link]);
} else {
[Link](action).setVisibility([Link]);
}
} else {
[Link]([Link]);
}

private void setClick(View view) {

[Link](this);
}

public void setSelctedImage(int position) {

Log.e("position", "" + position);
[Link](position -
1).setImageDrawable([Link](getApplicationContext(),
[Link](position - 1)));

@Override
public void onClick(View view) {
isZoomClick = false;
Intent intent;
switch ([Link]()) {

case [Link].btn_cleaner_back:
if (!isZoomEnabled()) {
clear_layout.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;
}
break;

case [Link].btn_back:
setUnselectImage();
showExitDialog();
break;

case [Link].btn_brush_back:
if (!isZoomEnabled()) {
if (layout_brush_setting.getVisibility() == [Link]) {
layout_brush_setting.setVisibility([Link]);
rec_brush_color.setVisibility([Link]);
} else if (rec_brush_color.getVisibility() == [Link]) {
layout_brush.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;
}
}
break;

case [Link].btn_pencil_back:
if (!isZoomEnabled()) {
if (layout_pencil.getVisibility() == [Link]) {

layout_pencil.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;
}
}
break;
case [Link].btn_magic_back:
if (!isZoomEnabled()) {
if (layout_magic_brush.getVisibility() == [Link]) {

layout_magic_brush.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;
}
}
break;
case [Link].btn_add_text_back:
if (!isZoomEnabled()) {
if (layout_add_text.getVisibility() == [Link]) {
 layout_add_text.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;
}
for (int i = 0; i < [Link](); i++) {
[Link](i).setInEdit(false);
}
}
break;

case [Link].btn_brush_setting:
if (!isZoomEnabled()) {
rec_brush_color.setVisibility([Link]);
layout_brush_setting.setVisibility([Link]);
action = 3;
}
break;

case [Link].btn_color:
if (!isZoomEnabled()) {
[Link]()
.setDialogType(ColorPickerDialog.TYPE_CUSTOM)
.setAllowPresets(false)
.setDialogId(0)
.setColor([Link])
.setShowAlphaSlider(true)
.show(this);
}
break;
case [Link].btn_zoom:
isZoomClick = true;

if (isZoomEnabled()) {
[Link]([Link]);
bottom_layout.setBackgroundColor([Link]);
[Link]([Link]);
[Link](false, imageView);
top_layout.setBackgroundColor([Link]);

[Link]([Link](getApplicationContext(),
[Link].toolbar_header));

btn_zoom.setImageDrawable([Link](getApplicationContext(),
[Link].ic_zoom_out_map_black_24dp));
} else {
[Link]([Link]);
btn_ok.setVisibility([Link]);
[Link]([Link]);

bottom_layout.setBackgroundColor([Link](getApplicationContext(),
[Link]));

top_layout.setBackgroundColor([Link](getApplicationContext(),
[Link]));

[Link]([Link](getApplicationContext(),
[Link]));
[Link](true, imageView);
btn_zoom.setImageDrawable([Link](getApplicationContext(),
[Link].ic_zoom));

break;
case [Link].btn_ok:
[Link]([Link]);
btn_ok.setVisibility([Link]);
[Link](true);

break;
case [Link].btn_brush:
if (!isZoomEnabled()) {
setUnselectImage();
isPaintSelected = true;
[Link](false);
[Link](true);
[Link](false);
isPencil = false;
setBackgroundView();
[Link](brush_size);
[Link](brush_smooth_size);
[Link](brushColor);
goneAllLayout();
[Link]([Link]);
isToolsLayoutVisible = false;
layout_brush.setVisibility([Link]);
action = 4;
rec_brush_color.setVisibility([Link]);

setSelctedImage([Link]);
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]));
}
break;
case [Link].btn_redo:
if (!isZoomEnabled()) {
setUnselectImage();
[Link]();
setSelctedImage([Link]);
setSelctedImage([Link]);

break;
case [Link].btn_undo:

if (!isZoomEnabled()) {
setUnselectImage();
[Link]();
setSelctedImage([Link]);
setSelctedImage([Link]);

}
 break;
case [Link].btn_clear:

if (!isZoomEnabled()) {
setUnselectImage();
setSelctedImage([Link]);

if (isPaintSelected) {

if ([Link]()) {

[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link].clean_selected));

[Link]();

[Link](Constants.MAGIC_BRUSH -
1).setImageDrawable([Link](getApplicationContext(),
[Link].magic_tool_selected));
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]));
} else {
goneAllLayout();

[Link]([Link]);
isToolsLayoutVisible = false;
clear_layout.setVisibility([Link]);
action = 0;

if (isPencil) {
brush_eraser_size.setProgress(pencil_erase_size);
} else {
brush_eraser_size.setProgress(brush_erase_size);
}

[Link](true);

}
} else {
goneAllLayout();
[Link]([Link]);
isToolsLayoutVisible = false;
clear_layout.setVisibility([Link]);
action = 0;
[Link](true);
[Link](true);
}
}
break;
case [Link].btn_refresh:

if (!isZoomEnabled()) {
setUnselectImage();
[Link]();
[Link]();
goneAllLayout();
 clear_layout.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;

}
break;
case [Link].btn_save:

if (!isZoomEnabled()) {
setUnselectImage();

for (int i = 0; i < [Link](); i++) {

[Link](i).setInEdit(false);
}

for (int i = 0; i < [Link](); i++) {

[Link](i).setInEdit(false);
}
btn_zoom.setVisibility([Link]);

if (!checkPermission(getApplicationContext())) {
requestPermission();
} else {
new DownloadSaveImageTask().execute();
}
}
break;
case [Link].btn_magic_brush:

if (!isZoomEnabled()) {
setUnselectImage();
setSelctedImage(Constants.MAGIC_BRUSH);
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]));
[Link](true);
isPaintSelected = true;
goneAllLayout();
[Link]([Link]);
isToolsLayoutVisible = true;

goneAllLayout();
[Link](true);
layout_magic_brush.setVisibility([Link]);
action = 5;
}
break;
case [Link].btn_pencil:
if (!isZoomEnabled()) {
setUnselectImage();
setSelctedImage([Link]);
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]));
[Link](true);
isPaintSelected = true;
[Link](false);
[Link](false);
 goneAllLayout();
setBackgroundView();
[Link]([Link]);
isToolsLayoutVisible = true;
action = -1;
isPencil = true;
[Link](2);
[Link](pencilColor);
[Link](0);
layout_pencil.setVisibility([Link]);
action = 2;
}

break;
case [Link].btn_sticker:
if (!isZoomEnabled()) {
setUnselectImage();
[Link](false);
isPaintSelected = false;
goneAllLayout();
intent = new Intent([Link],
[Link]);
startActivityForResult(intent, REQUEST_STICKER);
}
break;
case [Link].btn_add_text:
if (!isZoomEnabled()) {
setUnselectImage();
[Link](false);
isPaintSelected = false;
goneAllLayout();
showTextDialog(false, getString([Link]));
}
break;

enableDisableUndo();

public void addBubbleStickerView(String str) {

[Link](false);
mCurrentEditTextView = new TextStickerView(this);
[Link](str);
[Link]([Link]);

[Link](new
[Link]() {
@Override
public void onDeleteClick(TextStickerView textStickerView) {
[Link](textStickerView);
[Link](textStickerView);
}

@Override
public void onEdit(TextStickerView textStickerView) {
 for (int i = 0; i < [Link](); i++) {
[Link](i).setInEdit(false);
}

goneAllLayout();
mCurrentEditTextView = textStickerView;
[Link](true);
layout_add_text.setVisibility([Link]);
[Link]([Link]);

@Override
public void onEditSticker(TextStickerView bubbleTextView) {
mCurrentEditTextView = bubbleTextView;
[Link](true);
showTextDialog(true, [Link]());

@Override
public void onClick(TextStickerView bubbleTextView) {
mCurrentEditTextView = bubbleTextView;
}

@Override
public void onTop(TextStickerView bubbleTextView) {

}
});

[Link] lp = new
[Link]([Link].MATCH_PARENT,
[Link].MATCH_PARENT);
[Link](mCurrentEditTextView, lp);
[Link](mCurrentEditTextView);

public boolean isZoomEnabled() {

if ([Link]() && !isZoomClick) {

[Link](this, "" + getString([Link].unselect_zoom),
Toast.LENGTH_SHORT).show();
}
return [Link]();
}

public void requestPermission() {

if([Link].SDK_INT >= Build.VERSION_CODES.TIRAMISU){

[Link](this, new String[]{
[Link].READ_MEDIA_IMAGES,
}, RequestPermissionCode);

}else{
 [Link](this, new String[]{
[Link].READ_EXTERNAL_STORAGE,
[Link].WRITE_EXTERNAL_STORAGE
}, RequestPermissionCode);
}

public void setCurrentTextFalse() {

if (mCurrentEditTextView != null) {
[Link](false);
layout_add_text.setVisibility([Link]);

Log.e("action", "" + action);

visibleActionLayout();
}
}

public boolean checkPermission(Context context) {

int i3 = [Link](context,
[Link].READ_EXTERNAL_STORAGE);
int i4 = [Link](context,
[Link].WRITE_EXTERNAL_STORAGE);

if([Link].SDK_INT >= Build.VERSION_CODES.TIRAMISU){

i4 = [Link](context,
[Link].READ_MEDIA_IMAGES);

return i4 == PackageManager.PERMISSION_GRANTED;

}
Log.e("check","==="+(i3 == PackageManager.PERMISSION_GRANTED
&& i4 == PackageManager.PERMISSION_GRANTED));

return i3 == PackageManager.PERMISSION_GRANTED
&& i4 == PackageManager.PERMISSION_GRANTED;

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[]
permissions, @NonNull int[] grantResults) {
if (requestCode == RequestPermissionCode) {
if ([Link] > 0 && grantResults[0] ==
PackageManager.PERMISSION_GRANTED) {
for (int i = 0; i < [Link](); i++) {
[Link](i).setInEdit(false);
}

new DownloadSaveImageTask().execute();
}
 }
[Link](requestCode, permissions, grantResults);
}

@Override
public void onColorPencilClick(View view, int i, String s) {
pencil_color_pos = i;
pencilColor = [Link](s);
[Link](pencilColor);

@Override
public void onDrawTouch() {
enableDisableUndo();
setCurrentEditFalse();
setCurrentTextFalse();
}

@SuppressLint("StaticFieldLeak")
public class DownloadSaveImageTask extends AsyncTask<String, Integer, Bitmap> {

protected void onPreExecute() {

protected Bitmap doInBackground(String... urls) {

SaveImage();

return null;
}

protected void onPostExecute(Bitmap result) {

btn_zoom.setVisibility([Link]);
[Link](getApplicationContext(), "" +
getString([Link].save_success), Toast.LENGTH_SHORT).show();

Intent intent = new Intent([Link], [Link]);

[Link]([Link], savePath);
startActivity(intent);

}
}

@Override
public void onColorBrushClick(View view, int i, String s) {
Log.e("i====", "" + i);
brush_color_pos = i;
brushColor = [Link](s);
[Link](brushColor);
 }

@Override
protected void onActivityResult(int requestCode, int resultCode, @Nullable
Intent data) {
[Link](requestCode, resultCode, data);
if (resultCode == RESULT_OK) {

if (requestCode == REQUEST_STICKER) {
assert data != null;
stickerlist =
[Link](Constants.EXTRA_SELECTED_IMAGES);
assert stickerlist != null;
for (int i = 0; i < [Link](); i++) {
Bitmap bitmap =
[Link](getApplicationContext(), [Link](i));
addStickerView(bitmap);
}
}
}
}

public void addStickerView(Bitmap img) {

final StickerView stickerView = new StickerView(getApplicationContext());
[Link](img);
[Link](new [Link]() {
@Override
public void onDeleteClick(StickerView stickerView) {
for (int i = 0; i < [Link](); i++) {
if ([Link](i).equals(stickerView)) {
[Link](stickerView);
[Link](stickerView);
}
}
}

@Override
public void onEdit(StickerView stickerView) {
mCurrentView = stickerView;
[Link](true);
}

@Override
public void onTop(StickerView stickerView) {
int position = [Link](stickerView);
if (position == [Link]() - 1) {
return;
}
StickerView stickerTemp = (StickerView) [Link](position);
[Link]([Link](), stickerTemp);
}
});
[Link] lp = new
[Link]([Link].MATCH_PARENT,
[Link].MATCH_PARENT);
[Link](stickerView, lp);
[Link](stickerView);
 [Link](stickerView);
setCurrentEdit(stickerView);
}

public void setCurrentEdit(StickerView stickerView) {

[Link](true);
}

public void setCurrentEditFalse() {

if (mCurrentView != null) {
[Link](false);
}

public void enableDisableUndo() {

if ([Link]() > 0) {
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]([Link] - 1).icon));

} else {
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]([Link] - 1).unSelectedIcon));
}
if ([Link]() > 0) {
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]([Link] - 1).icon));
} else {
[Link]([Link] -
1).setImageDrawable([Link](getApplicationContext(),
[Link]([Link] - 1).unSelectedIcon));
}

private void SaveImage() {

// TODO Auto-generated method stub

String path = [Link](getApplicationContext()) +

Constants.SAVED_PAINT_IMG_PATH;

File dir = new File(path);

if (![Link]()) {
[Link]();
}
 Log.e("getAbsolutePath", "" + [Link]());

OutputStream output;

Bitmap bitmap = [Link]([Link](),

[Link](),
[Link].ARGB_8888);

Canvas b = new Canvas(bitmap);

[Link](b);

File saveFile1 = new File(dir, [Link]() + ".jpg");

savePath = [Link](saveFile1);
Log.e("saved path", savePath);

if ([Link]()) {
[Link]();
}

try {
output = new FileOutputStream(saveFile1);
[Link]([Link], 100, output);
[Link]();
[Link]();
} catch (Exception e) {
// TODO Auto-generated catch block
[Link]();
}
Intent mediaScanIntent = new Intent(
Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
Uri contentUri = [Link]("[Link]
+ [Link]());
[Link](contentUri);
(this).sendBroadcast(mediaScanIntent);
sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE,
[Link](new File([Link]()))));

@Override
public void onColorSelected(int dialogId, int color) {
if (mCurrentEditTextView != null) {
textColor = color;
[Link](color);
}
}

@Override
public void onDialogDismissed(int dialogId) {
}
 public void showTextDialog(boolean isEdit, String text) {
LayoutInflater layoutInflaterAndroid = [Link](this);
@SuppressLint("InflateParams") View mView =
[Link]([Link].dialog_add_text, null);
[Link] alertDialogBuilderUserInput = new
[Link](this);
[Link](mView);

final EditText editText = [Link]([Link]);

final Button btn_ok = [Link]([Link].btn_ok);
final Button btn_cancel = [Link]([Link].btn_cancel);

AlertDialog alertDialogAndroid = [Link]();

[Link]();

if (isEdit) {
[Link](text);
}

btn_ok.setOnClickListener(view -> {
if (.toString())) {
if (isEdit) {
if (mCurrentEditTextView != null) {

[Link]([Link]().toString());
}
layout_add_text.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = false;
} else {
addBubbleStickerView([Link]().toString());
layout_add_text.setVisibility([Link]);
[Link]([Link]);
isToolsLayoutVisible = false;
}
}

[Link](getApplicationContext(), editText);
[Link]();

});

btn_cancel.setOnClickListener(view -> {
[Link](getApplicationContext(), editText);
[Link]();
});