6.2a

app/src/main/java/ohi/andre/consolelauncher/commands/main/raw/music.java

+package ohi.andre.consolelauncher.commands.main.raw;
+
+import ohi.andre.consolelauncher.R;
+import ohi.andre.consolelauncher.commands.CommandAbstraction;
+import ohi.andre.consolelauncher.commands.ExecutePack;
+import ohi.andre.consolelauncher.commands.main.MainPack;
+import ohi.andre.consolelauncher.commands.specific.ParamCommand;
+import ohi.andre.consolelauncher.managers.music.MusicManager2;
+import ohi.andre.consolelauncher.managers.music.Song;
+import ohi.andre.consolelauncher.tuils.Tuils;
+
+public class music extends ParamCommand {
+
+    private enum Param implements ohi.andre.consolelauncher.commands.main.Param {
+        next {
+            @Override
+            public int[] args() {
+                return new int[0];
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                String title = ((MainPack) pack).player.playNext();
+                if(title != null) return pack.context.getString(R.string.output_playing) + Tuils.SPACE + title;
+                return null;
+            }
+        },
+        previous {
+            @Override
+            public int[] args() {
+                return new int[0];
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                String title = ((MainPack) pack).player.playPrev();
+                if(title != null) return pack.context.getString(R.string.output_playing) + Tuils.SPACE + title;
+                return null;
+            }
+        },
+        ls {
+            @Override
+            public int[] args() {
+                return new int[0];
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                return ((MainPack) pack).player.lsSongs();
+            }
+        },
+        play {
+            @Override
+            public int[] args() {
+                return new int[0];
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                String title = ((MainPack) pack).player.play();
+                if(title == null) return null;
+                return pack.context.getString(R.string.output_playing) + Tuils.SPACE + title;
+            }
+        },
+        stop {
+            @Override
+            public int[] args() {
+                return new int[0];
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                ((MainPack) pack).player.stop();
+                return null;
+            }
+        },
+        select {
+            @Override
+            public int[] args() {
+                return new int[] {CommandAbstraction.SONG};
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                String s = pack.get(String.class, 1);
+                ((MainPack) pack).player.select(s);
+                return null;
+            }
+        },
+        info {
+            @Override
+            public int[] args() {
+                return new int[0];
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                StringBuilder builder = new StringBuilder();
+
+                MusicManager2 m = ((MainPack) pack).player;
+                Song song = m.get(m.getSongIndex());
+
+                builder.append("Name: " + song.getTitle()).append(Tuils.NEWLINE);
+                if(song.getID() == -1) builder.append("Path: " + song.getPath()).append(Tuils.NEWLINE);
+                builder.append(Tuils.NEWLINE);
+
+                int curS = m.getCurrentPosition() / 1000;
+                int curMin = 0;
+                if(curS >= 60) {
+                    curMin = curS / 60;
+                    curS = curS % 60;
+                }
+
+                int s = m.getDuration() / 1000;
+                int min = 0;
+                if(s >= 60) {
+                    min = s / 60;
+                    s = s % 60;
+                }
+
+                builder.append((curMin > 0 ? curMin + "." + curS : curS + "s") + " of " + (min > 0 ? min + "." + s : s + "s") + " (" + (Tuils.percentage(m.getCurrentPosition(), m.getDuration())) + "%)");
+                return builder.toString();
+            }
+        },
+        seekto {
+            @Override
+            public int[] args() {
+                return new int[] {CommandAbstraction.INT};
+            }
+
+            @Override
+            public String exec(ExecutePack pack) {
+                ((MainPack) pack).player.seekTo(pack.get(int.class, 1) * 1000);
+                return null;
+            }
+        };
+
+        static Param get(String p) {
+            p = p.toLowerCase();
+            Param[] ps = values();
+            for (Param p1 : ps)
+                if (p.endsWith(p1.label()))
+                    return p1;
+            return null;
+        }
+
+        static String[] labels() {
+            Param[] ps = values();
+            String[] ss = new String[ps.length];
+
+            for (int count = 0; count < ps.length; count++) {
+                ss[count] = ps[count].label();
+            }
+
+            return ss;
+        }
+
+        @Override
+        public String label() {
+            return Tuils.MINUS + name();
+        }
+    }
+
+    @Override
+    protected ohi.andre.consolelauncher.commands.main.Param paramForString(MainPack pack, String param) {
+        return Param.get(param);
+    }
+
+    @Override
+    public int minArgs() {
+        return 0;
+    }
+
+    @Override
+    public int maxArgs() {
+        return 2;
+    }
+
+    @Override
+    public int priority() {
+        return 4;
+    }
+
+    @Override
+    public int helpRes() {
+        return R.string.help_music;
+    }
+
+    @Override
+    public String onArgNotFound(ExecutePack pack, int indexNotFound) {
+        return pack.context.getString(R.string.output_songnotfound);
+    }
+
+    @Override
+    public String onNotArgEnough(ExecutePack pack, int nArgs) {
+        return pack.context.getString(helpRes());
+    }
+
+    @Override
+    public String[] params() {
+        return Param.labels();
+    }
+
+    @Override
+    protected String doThings(ExecutePack pack) {
+        return null;
+    }
+}

app/src/main/java/ohi/andre/consolelauncher/managers/music/MusicController.java

+package ohi.andre.consolelauncher.managers.music;
+
+import android.content.Context;
+import android.widget.MediaController;
+
+public class MusicController extends MediaController {
+
+    public MusicController(Context c){
+        super(c);
+    }
+
+    public void hide(){}
+}
+

app/src/main/java/ohi/andre/consolelauncher/managers/music/MusicManager2.java

+package ohi.andre.consolelauncher.managers.music;
+
+import android.content.ComponentName;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.database.Cursor;
+import android.net.Uri;
+import android.os.IBinder;
+import android.provider.MediaStore;
+import android.widget.MediaController;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import ohi.andre.consolelauncher.managers.XMLPrefsManager;
+import ohi.andre.consolelauncher.tuils.Tuils;
+
+/**
+ * Created by francescoandreuzzi on 17/08/2017.
+ */
+
+public class MusicManager2 implements MediaController.MediaPlayerControl {
+
+    public static final String[] MUSIC_EXTENSIONS = {".mp3", ".wav", ".ogg", ".flac"};
+
+    final int WAITING_NEXT = 10, WAITING_PREVIOUS = 11, WAITING_PLAY = 12, WAITING_LISTEN = 13;
+
+    Context mContext;
+
+    List<Song> songs;
+    List<String> titles;
+
+    MusicService musicSrv;
+    boolean musicBound=false;
+    Intent playIntent;
+
+    boolean playbackPaused=true, stopped = true;
+
+    Thread loader;
+
+    int waitingMethod = 0;
+    String savedParam;
+
+    public MusicManager2(Context c) {
+        mContext = c;
+        updateSongs();
+
+        init();
+    }
+
+    public void init() {
+        playIntent = new Intent(mContext, MusicService.class);
+        mContext.bindService(playIntent, musicConnection, Context.BIND_AUTO_CREATE);
+        mContext.startService(playIntent);
+    }
+
+    public void refresh() {
+        destroy();
+        updateSongs();
+    }
+
+    public void destroy() {
+        if(musicSrv != null && musicBound) {
+            musicSrv.stop();
+            mContext.unbindService(musicConnection);
+            mContext.stopService(playIntent);
+            musicSrv = null;
+        }
+
+        musicBound = false;
+        playbackPaused = true;
+        stopped = true;
+    }
+
+    public String playNext() {
+        if(!musicBound) {
+            init();
+            waitingMethod = WAITING_NEXT;
+
+            return null;
+        }
+
+        playbackPaused=false;
+        stopped = false;
+
+        return musicSrv.playNext();
+    }
+
+    public String playPrev() {
+        if(!musicBound) {
+            init();
+            waitingMethod = WAITING_PREVIOUS;
+
+            return null;
+        }
+
+        playbackPaused = false;
+        stopped = false;
+
+        return musicSrv.playPrev();
+    }
+
+    @Override
+    public void pause() {
+        if(musicSrv == null) return;
+
+        playbackPaused=true;
+        musicSrv.pausePlayer();
+    }
+
+    public String play() {
+        if(!musicBound) {
+            init();
+            waitingMethod = WAITING_PLAY;
+
+            return null;
+        }
+
+        if(stopped) {
+            musicSrv.playSong();
+            playbackPaused = false;
+            stopped = false;
+        } else if(playbackPaused) {
+            playbackPaused = false;
+            musicSrv.playPlayer();
+        } else pause();
+
+        return null;
+    }
+
+    public String lsSongs() {
+        List<String> ss = new ArrayList<>();
+        for(Song s : songs) {
+            ss.add(s.getTitle());
+        }
+
+        Collections.sort(ss);
+        Tuils.addPrefix(ss, Tuils.DOUBLE_SPACE);
+        Tuils.insertHeaders(ss, false);
+
+        return Tuils.toPlanString(ss, Tuils.NEWLINE);
+    }
+
+    public void updateSongs() {
+        loader = new Thread() {
+            @Override
+            public void run() {
+                try {
+                    if(songs == null) songs = new ArrayList<>();
+                    else songs.clear();
+
+                    if(titles == null) titles = new ArrayList<>();
+                    else titles.clear();
+
+                    if(XMLPrefsManager.get(boolean.class, XMLPrefsManager.Behavior.songs_from_mediastore)) {
+                        ContentResolver musicResolver = mContext.getContentResolver();
+                        Uri musicUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
+                        Cursor musicCursor = musicResolver.query(musicUri, null, null, null, null);
+                        if(musicCursor!=null && musicCursor.moveToFirst()){
+                            int titleColumn = musicCursor.getColumnIndex(MediaStore.Audio.Media.TITLE);
+                            int idColumn = musicCursor.getColumnIndex(MediaStore.Audio.Media._ID);
+                            do {
+                                long thisId = musicCursor.getLong(idColumn);
+                                String thisTitle = musicCursor.getString(titleColumn);
+                                songs.add(new Song(thisId, thisTitle));
+                                titles.add(thisTitle);
+                            }
+                            while (musicCursor.moveToNext());
+                        }
+                        musicCursor.close();
+                    } else {
+                        String path = XMLPrefsManager.get(String.class, XMLPrefsManager.Behavior.songs_folder);
+                        if(path.length() > 0) {
+                            File dir = new File(path);
+                            if(dir.isDirectory()) songs.addAll(Tuils.getSongsInFolder(dir));
+
+                            for(Song s : songs) {
+                                titles.add(s.getTitle());
+                            }
+                        }
+                    }
+                } catch (Exception e) {
+                    Tuils.toFile(e);
+                }
+
+                synchronized (songs) {
+                    songs.notify();
+                }
+            }
+        };
+        loader.start();
+    }
+
+    private ServiceConnection musicConnection = new ServiceConnection(){
+
+        @Override
+        public void onServiceConnected(ComponentName name, IBinder service) {
+            MusicService.MusicBinder binder = (MusicService.MusicBinder)service;
+            musicSrv = binder.getService();
+            musicSrv.setShuffle(XMLPrefsManager.get(boolean.class, XMLPrefsManager.Behavior.random_play));
+
+            if(songs == null || loader.isAlive()) {
+                synchronized (songs) {
+                    try {
+                        songs.wait();
+                    } catch (InterruptedException e) {}
+                }
+            }
+            musicSrv.setList(songs);
+            musicBound = true;
+
+            switch (waitingMethod) {
+                case WAITING_NEXT:
+                    playNext();
+                    break;
+                case WAITING_PREVIOUS:
+                    playPrev();
+                    break;
+                case WAITING_PLAY:
+                    play();
+                    break;
+                case WAITING_LISTEN:
+                    select(savedParam);
+                    break;
+            }
+
+            waitingMethod = 0;
+            savedParam = null;
+        }
+
+        @Override
+        public void onServiceDisconnected(ComponentName name) {
+            musicBound = false;
+        }
+    };
+
+    @Override
+    public boolean canPause() {
+        return true;
+    }
+
+    @Override
+    public boolean canSeekBackward() {
+        return true;
+    }
+
+    @Override
+    public boolean canSeekForward() {
+        return true;
+    }
+
+    @Override
+    public int getAudioSessionId() {
+        return 0;
+    }
+
+    @Override
+    public int getBufferPercentage() {
+        return 0;
+    }
+
+    @Override
+    public int getCurrentPosition() {
+        if(musicSrv != null && musicBound && musicSrv.isPng())
+            return musicSrv.getPosn();
+        else return -1;
+    }
+
+    @Override
+    public int getDuration() {
+        if(musicSrv != null && musicBound && musicSrv.isPng())
+            return musicSrv.getDur();
+        else return -1;
+    }
+
+    public int getSongIndex() {
+        if(musicSrv != null) return musicSrv.getSongIndex();
+        return -1;
+    }
+
+    @Override
+    public boolean isPlaying() {
+        if(musicSrv != null && musicBound)
+            return musicSrv.isPng();
+        return false;
+    }
+
+    public void stop() {
+        destroy();
+    }
+
+    public Song get(int index) {
+        return songs.get(index);
+    }
+
+    @Override
+    public void seekTo(int pos) {
+        musicSrv.seek(pos);
+    }
+
+    public void select(String song) {
+        if(!musicBound) {
+            init();
+            waitingMethod = WAITING_LISTEN;
+            savedParam = song;
+
+            return;
+        }
+
+        int i = -1;
+        for(int index = 0; index < songs.size(); index++) {
+            if(songs.get(index).getTitle().equals(song)) i = index;
+        }
+
+        if(i == -1) {
+            return;
+        }
+
+        musicSrv.setSong(i);
+        musicSrv.playSong();
+    }
+
+    public List<String> getTitles() {
+        return titles;
+    }
+
+    @Override
+    public void start() {
+        musicSrv.go();
+    }
+}

app/src/main/java/ohi/andre/consolelauncher/managers/music/MusicService.java

+package ohi.andre.consolelauncher.managers.music;
+
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.ContentUris;
+import android.content.Context;
+import android.content.Intent;
+import android.media.AudioManager;
+import android.media.MediaPlayer;
+import android.net.Uri;
+import android.os.Binder;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.support.v4.app.NotificationCompat;
+import android.support.v4.app.RemoteInput;
+
+import java.io.IOException;
+import java.util.List;
+import java.util.Random;
+
+import ohi.andre.consolelauncher.LauncherActivity;
+import ohi.andre.consolelauncher.R;
+import ohi.andre.consolelauncher.tuils.InputOutputReceiver;
+import ohi.andre.consolelauncher.tuils.Tuils;
+
+public class MusicService extends Service implements
+        MediaPlayer.OnPreparedListener, MediaPlayer.OnErrorListener,
+        MediaPlayer.OnCompletionListener {
+
+    public static final int NOTIFY_ID=100001;
+
+    public static final String SONGTITLE_KEY = "songTitle";
+
+    private MediaPlayer player;
+    private List<Song> songs;
+    private int songPosn;
+    private final IBinder musicBind = new MusicBinder();
+    private String songTitle="";
+    private boolean shuffle=false;
+    private Random rand;
+
+    public void onCreate(){
+        super.onCreate();
+        songPosn=0;
+        rand=new Random();
+        player = new MediaPlayer();
+        initMusicPlayer();
+    }
+
+    public void initMusicPlayer(){
+        player.setWakeMode(getApplicationContext(), PowerManager.PARTIAL_WAKE_LOCK);
+        player.setAudioStreamType(AudioManager.STREAM_MUSIC);
+        player.setOnPreparedListener(this);
+        player.setOnCompletionListener(this);
+        player.setOnErrorListener(this);
+    }
+
+    public void setList(List<Song> theSongs){
+        songs=theSongs;
+    }
+
+    public class MusicBinder extends Binder {
+        MusicService getService() {
+            return MusicService.this;
+        }
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return musicBind;
+    }
+
+    @Override
+    public boolean onUnbind(Intent intent){
+        return super.onUnbind(intent);
+    }
+
+    public String playSong(){
+        try {
+            player.reset();
+        } catch (Exception e) {}
+
+        Song playSong = songs.get(songPosn);
+
+        long id = playSong.getID();
+        if(id == -1) {
+            String path = playSong.getPath();
+            try {
+                player.setDataSource(path);
+            } catch (IOException e) {
+                Tuils.log(e);
+                Tuils.toFile(e);
+                return null;
+            }
+        } else {
+            songTitle=playSong.getTitle();
+            long currSong = playSong.getID();
+            Uri trackUri = ContentUris.withAppendedId(android.provider.MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, currSong);
+            try {
+                player.setDataSource(getApplicationContext(), trackUri);
+            }
+            catch(Exception e) {
+                Tuils.log(e);
+                Tuils.toFile(e);
+                return null;
+            }
+        }
+        player.prepareAsync();
+
+        return playSong.getTitle();
+    }
+
+    public void setSong(int songIndex){
+        songPosn=songIndex;
+    }
+
+    @Override
+    public void onCompletion(MediaPlayer mp) {
+        if(player.getCurrentPosition()>0){
+            mp.reset();
+            playNext();
+        }
+    }
+
+    @Override
+    public boolean onError(MediaPlayer mp, int what, int extra) {
+        mp.reset();
+        return false;
+    }
+
+    @Override
+    public void onPrepared(MediaPlayer mp) {
+        mp.start();
+        startForeground(NOTIFY_ID, buildNotification(this.getApplicationContext(), songTitle));
+    }
+
+    public static Notification buildNotification(Context context, String songTitle) {
+        Intent notIntent = new Intent(context, LauncherActivity.class);
+        PendingIntent pendInt = PendingIntent.getActivity(context, 0, notIntent, PendingIntent.FLAG_UPDATE_CURRENT);
+
+        Notification not;
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
+        builder.setContentIntent(pendInt)
+                .setSmallIcon(R.mipmap.ic_launcher)
+                .setTicker(songTitle)
+                .setOngoing(true)
+                .setContentTitle("Playing")
+                .setContentText(songTitle);
+
+        if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            String label = "cmd";
+            RemoteInput remoteInput = new RemoteInput.Builder(InputOutputReceiver.TEXT)
+                    .setLabel(label)
+                    .build();
+
+            Intent i = new Intent(InputOutputReceiver.ACTION_CMD);
+            i.putExtra(InputOutputReceiver.WAS_KEY, InputOutputReceiver.WAS_MUSIC_SERVICE);
+
+            NotificationCompat.Action action = new NotificationCompat.Action.Builder(R.mipmap.ic_launcher, label,
+                    PendingIntent.getBroadcast(context.getApplicationContext(), 10, i, PendingIntent.FLAG_UPDATE_CURRENT))
+                    .addRemoteInput(remoteInput)
+                    .build();
+
+            builder.addAction(action);
+        }
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN) not = builder.build();
+        else not = builder.getNotification();
+
+        return not;
+    }
+
+    public int getPosn(){
+        return player.getCurrentPosition();
+    }
+
+    public int getDur(){
+        return player.getDuration();
+    }
+
+    public boolean isPng(){
+        return player.isPlaying();
+    }
+
+    public void pausePlayer(){
+        player.pause();
+    }
+
+    public void stop() {
+        player.stop();
+        player.release();
+        setSong(0);
+    }
+
+    public void playPlayer() {
+        player.start();
+    }
+
+    public void seek(int posn){
+        player.seekTo(posn);
+    }
+
+    public void go(){
+        player.start();
+    }
+
+    public String playPrev(){
+        songPosn--;
+        if(songPosn<0) songPosn=songs.size()-1;
+        return playSong();
+    }
+
+    public String playNext(){
+        if(shuffle){
+            int newSong = songPosn;
+            while(newSong==songPosn){
+                newSong=rand.nextInt(songs.size());
+            }
+            songPosn=newSong;
+        }
+        else{
+            songPosn++;
+            if(songPosn>=songs.size()) songPosn=0;
+        }
+
+        return playSong();
+    }
+
+    public int getSongIndex() {
+        return songPosn;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        stopForeground(true);
+    }
+
+    public void setShuffle(boolean shuffle){
+        this.shuffle = shuffle;
+    }
+
+}
\ No newline at end of file

app/src/main/java/ohi/andre/consolelauncher/managers/music/Song.java

+package ohi.andre.consolelauncher.managers.music;
+
+import java.io.File;
+
+/**
+ * Created by francescoandreuzzi on 17/08/2017.
+ */
+
+public class Song {
+
+    private long id;
+    private String title, path;
+
+    public Song(long songID, String songTitle) {
+        id = songID;
+        title = songTitle;
+    }
+
+    public Song(File file) {
+        String name = file.getName();
+        int dot = name.lastIndexOf(".");
+        name = name.substring(0,dot);
+
+        this.title = name;
+        this.path = file.getAbsolutePath();
+        this.id = -1;
+    }
+
+    public long getID() {
+        return id;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public String getPath() {
+        return path;
+    }
+}
+

app/src/main/java/ohi/andre/consolelauncher/tuils/InputOutputReceiver.java

+package ohi.andre.consolelauncher.tuils;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.support.v4.app.NotificationManagerCompat;
+import android.support.v4.app.RemoteInput;
+
+import ohi.andre.consolelauncher.managers.SkinManager;
+import ohi.andre.consolelauncher.tuils.interfaces.CommandExecuter;
+import ohi.andre.consolelauncher.tuils.interfaces.Outputable;
+
+/**
+ * Created by francescoandreuzzi on 18/08/2017.
+ */
+
+public class InputOutputReceiver extends BroadcastReceiver {
+
+    public static final int WAS_MUSIC_SERVICE = 10;
+    public static final int WAS_KEEPER_SERVICE = 11;
+
+    public static final String WAS_KEY = "was";
+
+    public static final String ACTION_CMD = "ohi.andre.consolelauncher.action_cmd";
+    public static final String ACTION_OUTPUT = "ohi.andre.consolelauncher.action_output";
+    public static final String TEXT = "ohi.andre.consolelauncher.text";
+    public static final String COLOR = "ohi.andre.consolelauncher.color";
+
+    CommandExecuter executer;
+    Outputable outputable;
+
+    public InputOutputReceiver(CommandExecuter executer, Outputable outputable) {
+        this.executer = executer;
+        this.outputable = outputable;
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
+        if(remoteInput == null || remoteInput.size() == 0) {
+            CharSequence text = intent.getCharSequenceExtra(TEXT);
+            if(text == null) text = intent.getStringExtra(TEXT);
+            if(text == null) return;
+
+            if(intent.getAction().equals(ACTION_CMD)) {
+                executer.exec(text.toString());
+            } else {
+                int color = intent.getIntExtra(COLOR, SkinManager.COLOR_NOT_SET);
+                outputable.onOutput(color, text);
+            }
+        } else {
+            String cmd = remoteInput.getString(TEXT);
+            executer.exec(cmd, true);
+
+            int was = intent.getIntExtra(WAS_KEY, 0);
+            if(was == WAS_KEEPER_SERVICE) {
+                NotificationManagerCompat.from(context).notify(KeeperService.ONGOING_NOTIFICATION_ID, KeeperService.buildNotification(context));
+            } else if(was == WAS_MUSIC_SERVICE) {
+//                do nothing
+            }
+        }
+    }
+}

app/src/main/java/ohi/andre/consolelauncher/tuils/libsuperuser/ShellHolder.java

+package ohi.andre.consolelauncher.tuils.libsuperuser;
+
+import android.os.Environment;
+
+import ohi.andre.consolelauncher.tuils.interfaces.Outputable;
+
+/**
+ * Created by francescoandreuzzi on 18/08/2017.
+ */
+
+public class ShellHolder {
+
+    private Outputable outputable;
+
+    public ShellHolder(Outputable outputable) {
+        this.outputable = outputable;
+    }
+
+    public Shell.Interactive build() {
+        Shell.Interactive interactive = new Shell.Builder()
+                .setOnSTDOUTLineListener(new StreamGobbler.OnLineListener() {
+                    @Override
+                    public void onLine(String line) {
+                        outputable.onOutput(line);
+                    }
+                })
+                .setOnSTDERRLineListener(new StreamGobbler.OnLineListener() {
+                    @Override
+                    public void onLine(String line) {
+                        outputable.onOutput(line);
+                    }
+                })
+                .open();
+        interactive.addCommand("cd " + Environment.getExternalStorageDirectory().getAbsolutePath());
+        return interactive;
+    }
+}