BaseFragment.java

package com.nf2m.fragment;

import android.animation.Animator;
import android.annotation.TargetApi;
import android.app.AlertDialog;
import android.app.SearchManager;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.content.IntentFilter;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Build;
import android.os.Bundle;
import android.provider.BaseColumns;
import android.provider.MediaStore;
import android.provider.MediaStore.Audio.PlaylistsColumns;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.app.LoaderManager;
import android.support.v4.content.ContextCompat;
import android.support.v4.content.CursorLoader;
import android.support.v4.content.Loader;
import android.support.v4.view.MenuItemCompat;
import android.support.v7.graphics.Palette;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.SearchView;
import android.support.v7.widget.SearchView.OnQueryTextListener;
import android.text.Editable;
import android.text.TextUtils;
import android.text.TextWatcher;
import android.transition.Slide;
import android.transition.Transition;
import android.util.Log;
import android.view.ActionMode;
import android.view.Gravity;
import android.view.LayoutInflater;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.MenuItem;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import com.nf2m.R;
import com.nf2m.activity.TarMediaPlayerActivity;
import com.nf2m.adapter.LibraryCursorAdapter;
import com.nf2m.listener.OnItemLongClickListener;
import com.nf2m.model.Library;
import com.nf2m.model.Playlists;
import com.nf2m.model.Songs;
import com.nf2m.preferences.Preferences;
import com.nf2m.service.MediaPlayerService;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import xyz.danoz.recyclerviewfastscroller.sectionindicator.title.SectionTitleIndicator;
import xyz.danoz.recyclerviewfastscroller.vertical.VerticalRecyclerViewFastScroller;


public abstract class BaseFragment extends Fragment implements
        ActionMode.Callback, View.OnClickListener, OnItemLongClickListener {
    private static final String STATE_ADD = "add";
    private static final String STATE_CREATE = "create";
    public static final String ACTION_SONG_DETAIL = "action_song_detail";
    public static final String KEY_SONG_TITLE = "key_song_title";
    public static final String KEY_ALBUM_ART_PATH = "key_album_art_path";
    public static final String ACTION_PLAY_STATE = "action_play_state";
    private static final String STATE_DELETE = "delete";
    private static final String SONG_ID_TAG = "OnlineSong ids";
    private static Menu menu;
    static String artistName;
    static String numberOfSongs;
    static String albumName;
    View view;
    static boolean isFilter;
    private int playlistId;
    private String state;
    private String searchSelection;
    private RecyclerView lvLibraryList;
    private Library libraries;
    @Nullable
    private Cursor libraryCursor;
    private LibraryCursorAdapter libraryAdapter;
    int selectionNumber;
    private String title_selectedNumber;
    private String title_addNewPlaylist;
    private String title_save;
    private String title_cancel;
    private String title_success_addNewPlaylist;
    private String title_ok;
    private String title_warning;
    private String playlistName;
    private String title_answer_delete;
    private String title_success_delete;
    private String title_success_addToPlaylist;
    private int selectedSongNumber;
    private String title_songSetAsRingtone;
    private String title_text_new_playlist;
    private String title_error;
    private ImageView ivPlayerPlay;
    private ImageView ivPlayerNext;
    private ImageView ivPlayerPrevious;
    private TextView tvSongDetails;
    private boolean isRegReciever;
    @Nullable
    private String filterText;
    private String where;
    private String[] selectionArgs;
    private ArrayList<String> selectionArray;
    @Nullable
    ActionMode actionMode;
    SearchView searchView;
    private boolean isNowPlayingList;
    public static boolean isAlbumSong = false;
    public static boolean isArtist = false;
    static String albumArtPath;
    @NonNull
    private final BroadcastReceiver playerReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, @NonNull Intent intent) {
            if (intent.getAction().equalsIgnoreCase(ACTION_SONG_DETAIL)) {
                Bundle data = intent.getExtras();
                String songTitle = data.getString(KEY_SONG_TITLE);
                String albumArtPath = data.getString(KEY_ALBUM_ART_PATH);
                Drawable albumArt = Drawable.createFromPath(albumArtPath);
                initPlayer(songTitle, albumArt);
                NowPlayingFragment.songTitle = songTitle;
                libraryAdapter.notifyDataSetChanged();

            } else if (intent.getAction().equalsIgnoreCase(ACTION_PLAY_STATE)) {
                Drawable playDrawable = choicePlayDrawable();
                ivPlayerPlay.setImageDrawable(playDrawable);
                libraryAdapter.notifyDataSetChanged();
            }
        }
    };

    @NonNull
    private final OnQueryTextListener onQueryTextListener = new OnQueryTextListener() {

        @Override
        public boolean onQueryTextSubmit(String query) {
            return false;
        }

        @Override
        public boolean onQueryTextChange(String newText) {
            filterText = !TextUtils.isEmpty(newText) ? newText : null;
            getLoaderManager().restartLoader(0, null, loaderCallbacks);
            return true;
        }
    };

    @Nullable
    private final LoaderManager.LoaderCallbacks<Cursor> loaderCallbacks = new LoaderManager.LoaderCallbacks<Cursor>() {
        @NonNull
        @Override
        public Loader<Cursor> onCreateLoader(int i, Bundle bundle) {

            if (filterText == null) {
                isFilter = false;
                return new CursorLoader(getActivity(), libraries.getUri(), null, where, selectionArgs, libraries.getSortOrder());
            } else {
                isFilter = true;
                String searchValueFirst = filterText + "%";
                String searchValueMiddle = "%" + filterText + "%";
                String searchValueLast = "%" + filterText;

                //album artist gibi şarkılar içinden ayrı bi liste oluşturulan yapılar için where kullanılır.
                if (where != null) {
                    return new CursorLoader(getActivity(), libraries.getUri(), null, where + " AND ( " +
                            searchSelection + " LIKE ? OR " + searchSelection
                            + " LIKE ? OR " + searchSelection + " LIKE ? )",
                            new String[]{selectionArgs[0], searchValueFirst, searchValueMiddle,
                                    searchValueLast}, libraries.getSortOrder());
                } else {
                    System.out.println(libraries.getUri() + "  " + libraries.getSortOrder());
                    return new CursorLoader(getActivity(), libraries.getUri(),
                            null, searchSelection + " LIKE ? OR " + searchSelection
                            + " LIKE ? OR " + searchSelection + " LIKE ? ",
                            new String[]{searchValueFirst, searchValueMiddle,
                                    searchValueLast}, libraries.getSortOrder());
                }
            }

        }

        @Override
        public void onLoadFinished(Loader<Cursor> loader, @Nullable Cursor cursor) {
            if (cursor == null) {
                cursor = libraries.getCursor();
            }
            libraryAdapter.swapCursor(cursor);
            libraryCursor = cursor;
        }

        @Override
        public void onLoaderReset(Loader<Cursor> loader) {
            libraryAdapter.swapCursor(null);
        }

    };


    private Cursor playlistCursor;
    private AlertDialog dialog;
    VerticalRecyclerViewFastScroller fastScroller;
    private SectionTitleIndicator sectionTitleIndicator;
    private Preferences preferences;
    private ViewGroup playerCustomView;
    private Cursor tempCursor;
    LinearLayoutManager linearLayoutManager;
    private ViewGroup albumSongLayout;
    private ImageView ivPlayerAlbumArt;
    private int primaryColor;
    private int primaryDarkColor;


    @TargetApi(Build.VERSION_CODES.KITKAT)
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {

        view = inflater.inflate(R.layout.list_layout, container, false);

        initMessages();
        setHasOptionsMenu(true);
        initPlayerVariables();
        initListener();
        initReceiver();
        initAlbumSong();

        return view;
    }

    @Override
    public void onViewCreated(View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        initPlayer(NowPlayingFragment.songTitle, initAlbumPath());
    }

    private Drawable initAlbumPath() {
        if (isAlbumSong) {
            if (albumArtPath != null) {
                return Drawable.createFromPath(albumArtPath);
            }
        } else if (MediaPlayerService.songsCursor != null && MediaPlayerService.songsCursor.getCount() != 0) {
            String albumId = MediaPlayerService.songsCursor.getString(MediaPlayerService.songsCursor.getColumnIndexOrThrow(MediaStore.Audio.AudioColumns.ALBUM_ID));
            albumArtPath = NowPlayingFragment.getAlbumPath(albumId, getContext());
            if (albumArtPath != null) {
                return Drawable.createFromPath(albumArtPath);
            }
        }
        albumArtPath = null;
        return null;
    }

    private void initAlbumSong() {
        if (isAlbumSong) {
            Drawable albumArt;
            albumSongLayout.setVisibility(View.VISIBLE);

            String songSize = getResources().getQuantityString(R.plurals.title_s_song, Integer.decode(numberOfSongs), Integer.decode(numberOfSongs));
            ImageView ivASAlbumArt = (ImageView) view.findViewById(R.id.ivASAlbumArt);
            TextView tvASAlbumName = (TextView) view.findViewById(R.id.tvASAlbumName);
            TextView tvASArtistName = (TextView) view.findViewById(R.id.tvASArtistName);
            TextView tvASSongSize = (TextView) view.findViewById(R.id.tvASSongSize);

            if (albumArtPath != null) {
                albumArt = Drawable.createFromPath(albumArtPath);
            } else {
                albumArt = getDrawable(R.drawable.ic_default_albumart);
            }

            ivASAlbumArt.setImageDrawable(albumArt);
            tvASAlbumName.setText(albumName);
            tvASArtistName.setText(artistName);
            tvASSongSize.setText(songSize);


        }
    }


    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        preferences = Preferences.newInstance(getContext());
    }

    private void initLoader() {
        getLoaderManager().initLoader(0, null, loaderCallbacks);
    }

    private void initReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(ACTION_SONG_DETAIL);
        filter.addAction(ACTION_PLAY_STATE);
        getActivity().registerReceiver(playerReceiver, filter);
        isRegReciever = true;
    }

    private void initListener() {
        ivPlayerPlay.setOnClickListener(this);
        ivPlayerNext.setOnClickListener(this);
        ivPlayerPrevious.setOnClickListener(this);
        tvSongDetails.setOnClickListener(this);
    }

    private void initPlayerVariables() {
        ivPlayerPlay = (ImageView) view.findViewById(R.id.ivPlayerPlay);
        ivPlayerNext = (ImageView) view.findViewById(R.id.ivPlayerNext);
        ivPlayerPrevious = (ImageView) view.findViewById(R.id.ivPlayerPrevious);
        ivPlayerAlbumArt = (ImageView) view.findViewById(R.id.ivPlayerAlbumArt);
        tvSongDetails = (TextView) view.findViewById(R.id.tvPlayerSongDetail);
        playerCustomView = (ViewGroup) view.findViewById(R.id.playerCustomView);
        albumSongLayout = (ViewGroup) view.findViewById(R.id.albumSongCustomFrame);
    }

    private void initPlayer(@Nullable String songTitle, Drawable albumArt) {
        if (albumArt != null) {
            ivPlayerAlbumArt.setImageDrawable(albumArt);
        } else {
            albumArt = getDrawable(R.drawable.ic_default_albumart);
            ivPlayerAlbumArt.setImageDrawable(albumArt);
        }

        initColor(albumArtPath);

        if (TarMediaPlayerActivity.sdkInt >= Build.VERSION_CODES.LOLLIPOP) {
            setAnimMaterial(primaryColor, primaryDarkColor);
        } else {
            setAnim(primaryColor);
        }

        if (tvSongDetails != null && songTitle != null) {
            tvSongDetails.setText(songTitle);
        }


        Drawable playDrawable = choicePlayDrawable();
        ivPlayerPlay.setImageDrawable(playDrawable);
    }

    private void initColor(String albumArtPath) {
        Bitmap bitmap = BitmapFactory.decodeFile(albumArtPath);
        if (bitmap != null) {
            Palette palette = Palette.from(bitmap).generate();
            primaryColor = palette.getVibrantColor(getColor(R.color.primary_text));
            primaryDarkColor = palette.getDarkVibrantColor(getColor(R.color.primary_text));
        } else {
            primaryColor = getColor(R.color.primary);
            primaryDarkColor = getColor(R.color.primary_dark);
        }

    }

    private int getColor(int id) {
        return ContextCompat.getColor(getContext(), id);
    }

    private Drawable choicePlayDrawable() {
        if (MediaPlayerService.isPlaying) {
            return getDrawable(R.drawable.ic_pause);
        } else {
            return getDrawable(R.drawable.ic_play);
        }
    }

    private Drawable getDrawable(int id) {
        return ContextCompat.getDrawable(getContext(), id);
    }

    @Override
    public void onClick(@NonNull View v) {
        switch (v.getId()) {
            case R.id.ivPlayerPlay:
                Intent playIntent = new Intent(MediaPlayerService.ACTION_PLAY);
                getActivity().sendBroadcast(playIntent);
                break;
            case R.id.ivPlayerNext:
                Intent nextIntent = new Intent(MediaPlayerService.ACTION_NEXT);
                getActivity().sendBroadcast(nextIntent);
                break;
            case R.id.ivPlayerPrevious:
                Intent previousIntent = new Intent(MediaPlayerService.ACTION_PREVIOUS);
                getActivity().sendBroadcast(previousIntent);
                break;
            case R.id.bAddNewPlaylist:
                addNewPlaylist(tempCursor);
                dialog.dismiss();
                actionMode.finish();
                break;
            case R.id.tvPlayerSongDetail:
                TarMediaPlayerActivity.item_state = TarMediaPlayerActivity.ITEM_STATE_NOW;
                getActivity().onBackPressed();
                break;
        }
    }


    @Override
    public void onDestroy() {
        if (isRegReciever) {
            getActivity().unregisterReceiver(playerReceiver);
        }
        super.onDestroy();
    }


    @NonNull
    MenuInflater getMenuInflater() {
        return getActivity().getMenuInflater();
    }

    @NonNull
    LayoutInflater getLayoutInflater() {
        return getActivity().getLayoutInflater();
    }


    // ------------------------GET-SET------------------------------------------


    String getWhere() {
        return where;
    }

    ArrayList<String> getSelectionArray() {
        return selectionArray;
    }

    boolean isNowPlayingList() {
        return isNowPlayingList;
    }

    void setLvLibraryList(@NonNull RecyclerView lvLibraryList) {
        this.lvLibraryList = lvLibraryList;
        lvLibraryList.setHasFixedSize(true);
        fastScroller = (VerticalRecyclerViewFastScroller) view.findViewById(R.id.fast_scroller);
        sectionTitleIndicator =
                (SectionTitleIndicator) view.findViewById(R.id.fast_scroller_section_title_indicator);

        fastScroller.setRecyclerView(lvLibraryList);
        lvLibraryList.addOnScrollListener(fastScroller.getOnScrollListener());
        fastScroller.setSectionIndicator(sectionTitleIndicator);

    }

    void setLibraryAdapter(final LibraryCursorAdapter libraryAdapter) {
        this.libraryAdapter = libraryAdapter;
    }


    void setLibraryCursor(Cursor libraryCursor) {
        this.libraryCursor = libraryCursor;
    }


    void setLibraries(Library libraries) {
        this.libraries = libraries;
    }

    void setSearchSelection(String searchSelection) {
        this.searchSelection = searchSelection;
    }

    void setSelectedSongNumber(int selectedSongNumber) {
        this.selectedSongNumber = selectedSongNumber;
    }

    void setWhere(String where) {
        this.where = where;
    }

    void setSelectionArgs(String[] selectionArgs) {
        this.selectionArgs = selectionArgs;
    }

    void setSelectionArray(ArrayList<String> selectionArray) {
        this.selectionArray = selectionArray;
    }

    void setNowPlayingList(boolean nowPlayingList) {
        isNowPlayingList = nowPlayingList;
    }

    // ------------------------GET-SET------------------------------------------

    // ------------------------INIT-MESSAGE-------------------------------------

    /**
     * Xmlden mesajlar getirilir.
     */
    private void initMessages() {
        title_selectedNumber = getMessage(R.string.title_selectedNumber);
        title_addNewPlaylist = getMessage(R.string.title_addNewPlaylist);
        title_save = getMessage(R.string.title_save);
        title_cancel = getMessage(R.string.title_cancel);
        title_success_addNewPlaylist = getMessage(R.string.title_success_addNewPlaylist);
        title_ok = getMessage(R.string.title_ok);
        title_warning = getMessage(R.string.title_warning);
        title_songSetAsRingtone = getMessage(R.string.title_songAsPhoneRingtone);
        title_text_new_playlist = getMessage(R.string.title_text_new_playlist);
        title_error = getMessage(R.string.titleDeleteError);
    }

    private String successAddToPlaylistMessage() {
        return getResources().getQuantityString(R.plurals.title_p_success_addToPlaylist,
                selectedSongNumber, selectedSongNumber);
    }

    private String answerDeleteMessage() {
        return getResources().getQuantityString(R.plurals.title_p_answer_delete, selectedSongNumber);
    }

    private String successDeleteMessage() {
        return getResources().getQuantityString(R.plurals.title_p_success_delete,
                selectedSongNumber, selectedSongNumber);
    }


    private String getMessage(int resource) {
        return getResources().getString(resource);
    }

    // ------------------------INIT-MESSAGE-------------------------------------

    // ------------------------INIT-SELECTED-CURSOR------------------------------

    /**
     * Seçilmiş itemler üzerinde işlemler(silme,ekleme vb.) yapmak için library
     * sınıfının cursorü set edilir. Bu cursor içinde seçilmiş sarkılar vardır.
     */
    @Nullable
    protected abstract Cursor initSelectedItemCursor();

    /**
     * Adapterden alınan seçilmiş itemların özellikleri bir string arraye
     * kaydedilir.
     */
    @NonNull
    String[] getStringArray(String uri) {
        List<String> stringList = getStringListInLibrary(uri);
        String[] libraryStrings = new String[stringList.size()];
        stringList.toArray(libraryStrings);
        return libraryStrings;
    }

    /**
     * Adapterdeki seçilmiş itemların listviewdeki posizyonları alınıp bu
     * itemların özellikleri alınır. Ve bir liste eklenir.
     */
    @NonNull
    private List<String> getStringListInLibrary(String uri) {
        List positionList = libraryAdapter.getPositionList();
        List<String> stringList = new LinkedList<>();
        for (int i = 0; i < positionList.size(); i++) {
            stringList.add(getStringInLibraryCursor((Integer) positionList.get(i), uri));

        }
        Log.i(SONG_ID_TAG, stringList.toString());
        return stringList;
    }

    /**
     * Cursordeki bir ögenin özellikleri alınır.
     */
    private String getStringInLibraryCursor(int position, String uri) {
        libraryCursor.moveToPosition(position);
        return libraryCursor.getString(getColumnIndex(uri));
    }

    /**
     * Cursordeki bir sütunun indexi alınır.
     */
    private int getColumnIndex(String uri) {
        return libraryCursor.getColumnIndexOrThrow(uri);
    }

    /**
     * Seçilmiş itemların şarkı cursorde bulunması için kullanılır.
     */
    String getSelection(String column, @NonNull String[] args) {
        String selection = column + " IN (";
        for (int i = 0; i < args.length; i++) {
            selection += args[i];
            if (i < args.length - 1) {
                selection += ",";
            }
        }
        selection += ")";
        return selection;
    }

    // ------------------------INIT-SELECTED-CURSOR------------------------------

    // ------------------------ITEM-LONG-CLICK------------------------------------

    @Override
    public void onItemLongClick(int position) {
        if (actionMode != null) {
            return;
        }

        actionMode = TarMediaPlayerActivity.toolbar.startActionMode(this);
        toggleSelection(position);
    }

    // ------------------------ITEM-LONG-CLICK------------------------------------

    // ------------------------TOUCH-LISTENER--------------------------------------

    /**
     * Bir öge sürüklenirse ekranın sağında bir oynatma listesi çıkar.Bu
     * listenin oluşturulması burada yapılır.
     *
     * @param songCursor
     */
    private void createPlaylistView(final Cursor songCursor) {

        final ArrayAdapter<String> arrayAdapter = new ArrayAdapter<>(
                getActivity(),
                android.R.layout.simple_selectable_list_item);

        View popupLayout = getLayoutInflater().inflate(
                R.layout.playlist_popup_layout, null);
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setView(popupLayout);

        Button bAddNewPlaylist = (Button) popupLayout
                .findViewById(R.id.bAddNewPlaylist);
        bAddNewPlaylist.setOnClickListener(this);
        tempCursor = songCursor;

        Library playlist = new Playlists(getContext());
        playlistCursor = playlist.getCursor();

        if (playlistCursor.getCount() != 0) {
            playlistCursor.moveToFirst();
            do {
                String playlistName = playlistCursor.getString(playlistCursor.getColumnIndexOrThrow(PlaylistsColumns.NAME));
                arrayAdapter.add(playlistName);
            } while (playlistCursor.moveToNext());
        }

        builder.setAdapter(arrayAdapter, new OnClickListener() {
            @Override
            public void onClick(@NonNull DialogInterface dialog, int which) {
                addToPlaylist(which, songCursor);
                dialog.dismiss();
                actionMode.finish();
            }
        });

        dialog = builder.create();
        dialog.show();

    }


    // ------------------------MULTICHOICE-LISTENER---------------------------------------
//    @Override
    public boolean onCreateActionMode(ActionMode mode, @NonNull Menu menu) {
        BaseFragment.menu = menu;
        getMenuInflater().inflate(R.menu.song_activity_context_menu, menu);
        menu.findItem(R.id.scmRemove).setVisible(false);
        menu.findItem(R.id.scmRemoveSelect).setVisible(false);
        return true;
    }


    // ------------------------TOUCH-LISTENER--------------------------------------

    // ------------------------DRAG-LISTENER---------------------------------------

    @Override
    public boolean onPrepareActionMode(ActionMode mode, Menu menu) {

        return false;
    }

    // ------------------------DRAG-LISTENER---------------------------------------------

    @Override
    public boolean onActionItemClicked(@NonNull ActionMode mode, @NonNull MenuItem item) {

        Cursor songCursor = initSelectedItemCursor();

        switch (item.getItemId()) {

            case R.id.scmSelectAll:
                menu.findItem(R.id.scmRemoveSelect).setVisible(true);
                menu.findItem(R.id.scmSelectAll).setVisible(false);
                libraryAdapter.selectAllItem();
                selectionNumber = libraryCursor.getCount();
                mode.setTitle(selectionNumber + " " + title_selectedNumber);
                break;

            case R.id.scmRemoveSelect:
                menu.findItem(R.id.scmRemoveSelect).setVisible(false);
                menu.findItem(R.id.scmSelectAll).setVisible(true);
                libraryAdapter.removeSelectAllItems();
                selectionNumber = 1;
                mode.setTitle(selectionNumber + " " + title_selectedNumber);
                break;

            case R.id.scmDelete:
                deleteSongsDialog(songCursor);
                break;

            case R.id.scmAddToPlaylist:
                createPlaylistView(songCursor);
                break;

            case R.id.scmSetAsPhoneRingtone:
                libraries.setAsPhoneRingtone(songCursor);
                toastMassege(title_songSetAsRingtone);
                actionMode.finish();
                break;

            case R.id.scmShare:
                libraries.share(songCursor);
                actionMode.finish();
                break;

            case R.id.scmSearch:
                String search = libraryCursor
                        .getString(getColumnIndex(searchSelection));
                libraries.search(search);
                actionMode.finish();
                break;

            case R.id.scmDetails:
                actionMode.finish();
                break;
        }
        return true;
    }

    /**
     * Silme işlemi yapılır.
     */
    private void deleteSongsDialog(final Cursor songCursor) {

        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
        builder.setTitle(title_warning);
        choicePluralOrSingularMessage();
        builder.setMessage(title_answer_delete);

        builder.setPositiveButton(title_ok, new OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                state = STATE_DELETE;
                new BackgroundTask(songCursor).execute();
                actionMode.finish();
            }
        });
        builder.setNegativeButton(title_cancel, new OnClickListener() {

            @Override
            public void onClick(@NonNull DialogInterface dialog, int which) {
                dialog.cancel();

            }
        });
        AlertDialog dialog = builder.create();
        dialog.show();

    }

    @Override
    public void onDestroyActionMode(ActionMode mode) {
        libraryAdapter.clearSelection();
        selectionNumber = 0;
        actionMode = null;
    }

    // ------------------------DELETE---------------------------------------


    void toggleSelection(int position) {
        if (!libraryAdapter.isPositionChecked(position)) {
            libraryAdapter.addNewSelection(position, true);
            selectionNumber++;

        } else {
            libraryAdapter.removeSelection(position);
            selectionNumber--;
        }

        if (selectionNumber == 0) {
            actionMode.finish();
            return;
        }
        actionMode.setTitle(selectionNumber + " " + title_selectedNumber);
    }

    // ------------------------DELETE---------------------------------------

    /**
     * Tekil veya çoğul mesajları seçer.Eğer bir şarkı seçildiyse tekil birden
     * fazla şarkı seçilirse çoğul mesaj set edilir.
     */
    private void choicePluralOrSingularMessage() {
        title_answer_delete = answerDeleteMessage();
        title_success_delete = successDeleteMessage();
        title_success_addToPlaylist = successAddToPlaylistMessage();
    }

    private void toastMassege(String message) {
        Toast.makeText(getContext(), message, Toast.LENGTH_SHORT)
                .show();
    }

    // ------------------------MULTICHOICE-LISTENER---------------------------------------

    // ------------------------BACKGROUND-TASK--------------------------------------------


    /**
     * Arama çubuğu eklendi. Bulunduğu listenin tipine göre arama yapmaktadır.
     * Şarkı listesi ise bu listeden şarkı araması yapmaktadpır.
     */
    @Override
    public void onCreateOptionsMenu(@NonNull Menu menu, @NonNull MenuInflater inflater) {
        super.onCreateOptionsMenu(menu, inflater);
        inflater.inflate(R.menu.base_options_menu, menu);
        menu.findItem(R.id.omAddNewPlaylist).setVisible(false);
        initSearchItem(menu);
    }

    private void initSearchItem(@NonNull Menu menu) {
        initLoader();
        final SearchManager manager = (SearchManager) getContext().getSystemService(Context.SEARCH_SERVICE);
        MenuItem item = menu.findItem(
                R.id.omSearchView);
        searchView = (SearchView) MenuItemCompat.getActionView(item);

        searchView.setSearchableInfo(manager
                .getSearchableInfo(getActivity().getComponentName()));
        searchView.setOnQueryTextListener(onQueryTextListener);
    }


    /**
     * Eğer liste filtrelenmiş ise bizim ana listedeki pozisyonu döndürür.
     * Filtrelenmiş listedeki pozisyonu alıp gerçek listedeki yeri bulunur.
     */
    int getPositionInMainCursor(int filteredPosition) {
        Cursor mainCursor = libraries.getCursor();
        mainCursor.moveToFirst();
        libraryCursor.moveToPosition(filteredPosition);
        int songId = libraryCursor.getInt(libraryCursor.getColumnIndexOrThrow(MediaStore.Audio.AudioColumns._ID));
        do {
            int tempSongId = mainCursor.getInt(mainCursor.getColumnIndexOrThrow(MediaStore.Audio.AudioColumns._ID));
            if (songId == tempSongId) {
                break;
            }
        } while (mainCursor.moveToNext());

        return mainCursor.getPosition();
    }

    /**
     * Eğer edittext boş ise save butonu işlemez hale gelir
     */
    void playlistNameKeyListener(@NonNull final AlertDialog dialog, @NonNull final EditText etNewPlaylistName) {

        etNewPlaylistName.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence s, int start, int count, int after) {

            }

            @Override
            public void onTextChanged(CharSequence s, int start, int before, int count) {
                if (etNewPlaylistName.getText().toString().isEmpty()) {
                    dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(false);
                } else {
                    dialog.getButton(AlertDialog.BUTTON_POSITIVE).setEnabled(true);
                }
            }

            @Override
            public void afterTextChanged(Editable s) {

            }
        });

    }

    /**
     * Yeni bir şarkı listesi oluşturulacağı zaman varsayılan olarak bir
     * isim verilir.
     */
    @Nullable
    String createNewPlaylistName(@NonNull Cursor playlistCursor) {
        String newPlaylistName = null;
        try {
            for (int i = 1; i <= playlistCursor.getCount() + 1; i++) {
                boolean existName = false;
                newPlaylistName = title_text_new_playlist + i;

                if (playlistCursor.getCount() != 0) {
                    playlistCursor.moveToFirst();
                    do {
                        String playlistName = playlistCursor
                                .getString(playlistCursor
                                        .getColumnIndexOrThrow(PlaylistsColumns.NAME));
                        if (playlistName.equals(newPlaylistName)) {
                            existName = true;
                            break;
                        }
                    } while (playlistCursor.moveToNext());

                    if (!existName) {
                        break;
                    }
                }

            }
            playlistCursor.close();
        } catch (NullPointerException e) {
            e.printStackTrace();
            newPlaylistName = title_text_new_playlist;
        }

        return newPlaylistName;
    }

    Uri getPlaylistUri() {
        return MediaStore.Audio.Playlists.EXTERNAL_CONTENT_URI;
    }


    // -------------------------SONG LIST REMOVE AND ADD------------------


    // -------------------------SONG LIST REMOVE AND ADD------------------


    /**
     * Oynatma listeslerinden herhangi birine öge eklenir.
     */
    private void addToPlaylist(int position, Cursor songCursor) {
        playlistCursor.moveToPosition(position);

        playlistId = playlistCursor.getInt(playlistCursor
                .getColumnIndexOrThrow(BaseColumns._ID));
        state = STATE_ADD;
        new BackgroundTask(songCursor).execute();

    }


    // ------------------------DRAG-LISTENER-ENTERED-------------------------------------

    // ------------------------DRAG-LISTENER-DROP-------------------------------------


    /**
     * Yeni bir oynatma listesi eklenir.
     */
    private void addNewPlaylist(final Cursor songCursor) {

        AlertDialog.Builder builder = new AlertDialog.Builder(
                getActivity());

        View newPlaylistView = getLayoutInflater().inflate(
                R.layout.add_newplaylist_alert_dialog_tv, null);
        final EditText etNewPlaylistName = (EditText) newPlaylistView
                .findViewById(R.id.etNewPlaylistName);

        String newPlaylistName = createNewPlaylistName(playlistCursor);
        etNewPlaylistName.setText(newPlaylistName);

        builder.setView(etNewPlaylistName);
        final AlertDialog dialog = builder.create();

        etNewPlaylistName.setOnFocusChangeListener(new View.OnFocusChangeListener() {
            @Override
            public void onFocusChange(View v, boolean hasFocus) {
                if (hasFocus) {
                    dialog.getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_STATE_ALWAYS_VISIBLE);
                }
            }
        });


        playlistNameKeyListener(dialog, etNewPlaylistName);


        dialog.setTitle(title_addNewPlaylist);
        dialog.setButton(AlertDialog.BUTTON_POSITIVE, title_save, new OnClickListener() {

            @Override
            public void onClick(DialogInterface dialog, int which) {
                playlistName = etNewPlaylistName.getText().toString();
                if (!playlistName.isEmpty()) {
                    state = STATE_CREATE;
                    new BackgroundTask(songCursor).execute();
                }
            }
        });
        dialog.setButton(AlertDialog.BUTTON_NEGATIVE, title_cancel, new OnClickListener() {

            @Override
            public void onClick(@NonNull DialogInterface dialog, int which) {
                dialog.cancel();
            }
        });

        dialog.show();


    }


    // ------------------------DRAG-LISTENER-DROP-------------------------------------


    // -------------------------SONG ASYNCTASK---------------------------

    /**
     * Silme , ekleme ve oluşturma işlemleri bir arka plan servislerinde
     * yapılır.
     */
    private class BackgroundTask extends AsyncTask<Void, Void, Void> {

        private boolean deleteSuccess;
        private final Cursor songCursor;

        BackgroundTask(Cursor songCursor) {
            this.songCursor = songCursor;
        }

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            choicePluralOrSingularMessage();
        }


        @Nullable
        @Override
        protected Void doInBackground(Void... params) {
            if (state.equalsIgnoreCase(STATE_DELETE)) {

                deleteSuccess = libraries.deletedSongs(songCursor);
            } else if (state.equalsIgnoreCase(STATE_ADD)) {
                libraries.addToPlaylist(playlistId, songCursor);
            } else if (state.equalsIgnoreCase(STATE_CREATE)) {
                libraries.createPlaylist(playlistName, getPlaylistUri(), songCursor);
            }
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            super.onPostExecute(result);
            if (state.equalsIgnoreCase(STATE_DELETE)) {
                if (deleteSuccess) {
                    if (!libraries.getCursor().isClosed()) {
                        libraryAdapter.notifyDataSetChanged();
                        libraries.getCursor().requery();
                        toastMassege(title_success_delete);
                    }
                } else {
                    toastMassege(title_error);
                }
            } else if (state.equalsIgnoreCase(STATE_ADD)) {
                toastMassege(title_success_addToPlaylist);
            } else if (state.equalsIgnoreCase(STATE_CREATE)) {
                toastMassege(title_success_addNewPlaylist);
                toastMassege(title_success_addToPlaylist);
            }

        }

    }


    // ---------------------NOW PLAYING LIST ADD SONG TASK --------------------------------


    /**
     * recycler view layout managera bağlanır
     */
    void setLayoutManager() {
        linearLayoutManager = new LinearLayoutManager(getContext());
        linearLayoutManager.setOrientation(LinearLayoutManager.VERTICAL);
        scroll();
        lvLibraryList.setLayoutManager(linearLayoutManager);
    }

    private void scroll() {
        if (NowPlayingFragment.play_state.equalsIgnoreCase(NowPlayingFragment.PAUSE)) {
            linearLayoutManager.scrollToPosition(preferences.getPrefSongPosition());
        } else {
            linearLayoutManager.scrollToPosition(0);
        }
    }


    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    void setAnimMaterial(int primaryColor, int primaryColorDark) {

        getActivity().getWindow().setStatusBarColor(primaryColorDark);

        TarMediaPlayerActivity.toolbar.setBackgroundColor(primaryColor);
        playerCustomView.setBackgroundColor(primaryColor);
        sectionTitleIndicator.setBackgroundColor(primaryColor);
    }

    void setAnim(int primaryColor) {
        TarMediaPlayerActivity.toolbar.setBackgroundColor(primaryColor);
        playerCustomView.setBackgroundColor(primaryColor);
        sectionTitleIndicator.setBackgroundColor(primaryColor);
    }

    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    void initAnim(@NonNull Fragment fragment) {

        TarMediaPlayerActivity.slideTransition = new Slide();
        TarMediaPlayerActivity.slideTransition.addListener(new Transition.TransitionListener() {
            @Override
            public void onTransitionStart(Transition transition) {

            }

            @Override
            public void onTransitionEnd(Transition transition) {
            }

            @Override
            public void onTransitionCancel(Transition transition) {

            }

            @Override
            public void onTransitionPause(Transition transition) {

            }

            @Override
            public void onTransitionResume(Transition transition) {

            }
        });
        TarMediaPlayerActivity.slideTransition.setSlideEdge(Gravity.LEFT);
        TarMediaPlayerActivity.slideTransition.setDuration(200);
        fragment.setEnterTransition(TarMediaPlayerActivity.slideTransition);

    }


}