ziver/ue-control
1
0
Fork 0
Code Pull requests Releases Activity

Initial commit

Browse source
This commit is contained in:
Ziver Koc 2014-07-25 13:42:36 +02:00
commit b305095ab3
79 changed files with 4092 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

103
app/src/main/java/com/ericsson/uecontrol/core/UeBehaviour.java Executable file
View file

@ -0,0 +1,103 @@
package com.ericsson.uecontrol.core;
/**
* Base class for Ue behaviours that can be used by the executor
*
* Created by ezivkoc on 2014-07-15.
*/
public abstract class UeBehaviour {
private boolean running;
private BehaviourExecutionListener execListener;
private DataHandledListener datahandledListener;
/**
* Starts to run the behaviour, this method will block until the execution is done
*/
public synchronized void run(){
running = true;
if(execListener != null) execListener.executionStarted();
execute();
if(execListener != null) execListener.executionStopped();
}
/**
* Will stop the currently running behaviour
*/
public synchronized void terminate(){
running = false;
}
/**
* @return if currently running behaviour should be terminated
*/
protected boolean stopExecution(){
return !running;
}
/**
* @return true is this behaviour is currently running
*/
public boolean isRunning(){
return running;
}
public void setExecutionListener(BehaviourExecutionListener l){
execListener = l;
}
protected void setProgress(float progress){
if(execListener != null)
execListener.progressChanged(progress);
// TODO: This is a dirty way of updating the throughput, should be changed
if(datahandledListener != null)
datahandledListener.handledIncomingData(0);
}
public void setDataHandledListener(DataHandledListener listener) {
datahandledListener = listener;
}
protected void setHandledIncomingData(long size){
if(datahandledListener != null)
datahandledListener.handledIncomingData(size);
}
protected void setHandledOutgoingData(long size){
if(datahandledListener != null)
datahandledListener.handledOutgoingData(size);
}
/**
* Executes the behaviour, will block until behaviour has run to completion.
*/
protected abstract void execute();
/**
* @return the short name of the behaviour
*/
public abstract String getName();
/**
* @return a longer description of the behaviour
*/
//public abstract String getDescription();
/**
* @return a nice String with the current settings
*/
public abstract String toString();
public static interface BehaviourExecutionListener {
public void executionStarted();
public void progressChanged(float progress);
public void executionStopped();
}
public static interface DataHandledListener {
public void handledIncomingData(long size);
public void handledOutgoingData(long size);
}
}

106
app/src/main/java/com/ericsson/uecontrol/core/UeControlExecutor.java Executable file
View file

@ -0,0 +1,106 @@
package com.ericsson.uecontrol.core;
import android.util.Log;
import com.ericsson.uecontrol.core.util.ThroughputCalculator;
import java.util.ArrayList;
import java.util.List;
/**
* Created by ezivkoc on 2014-07-15.
*/
public class UeControlExecutor implements Runnable, UeBehaviour.DataHandledListener {
private static final String TAG = "UeControlExecutor";
private List<UeBehaviour> behaviours;
private UeBehaviour currentlyActive;
private boolean terminate;
private Thread thread;
private ThroughputCalculator downloadSpeed;
private ThroughputCalculator uploadSpeed;
private ThroughputListener throughputListener;
public UeControlExecutor(){
behaviours = new ArrayList<UeBehaviour>();
downloadSpeed = new ThroughputCalculator();
uploadSpeed = new ThroughputCalculator();
}
public void addBehaviour(UeBehaviour b){
behaviours.add(b);
b.setDataHandledListener(this);
}
public void execute(){
if(thread == null || !thread.isAlive()) {
terminate = false;
thread = new Thread(this);
thread.start();
}
}
public void terminate(){
terminate = true;
if(currentlyActive != null);
currentlyActive.terminate();
}
public boolean isRunning(){
if(currentlyActive == null)
return false;
return currentlyActive.isRunning();
}
public void run(){
while(!terminate) {
if(behaviours.isEmpty()) {
terminate();
break;
}
else if (currentlyActive == null)
currentlyActive = behaviours.get(0);
Log.v(TAG, "Running behaviour: " + currentlyActive.getName());
currentlyActive.run();
int index = behaviours.indexOf(currentlyActive) +1;
if(index < behaviours.size())
currentlyActive = behaviours.get(index);
else
currentlyActive = null;
}
Log.v(TAG, "Execution completed");
}
@Override
public void handledIncomingData(long size) {
downloadSpeed.setHandledData(size);
if(throughputListener != null && downloadSpeed.isUpdated())
throughputListener.throughputUpdate(downloadSpeed.getThroughput(), uploadSpeed.getThroughput());
}
@Override
public void handledOutgoingData(long size) {
uploadSpeed.setHandledData(size);
if(throughputListener != null && uploadSpeed.isUpdated())
throughputListener.throughputUpdate(downloadSpeed.getThroughput(), uploadSpeed.getThroughput());
}
public void setThroughputListener(ThroughputListener listener){
throughputListener = listener;
}
public List<UeBehaviour> getBehaviourList() {
return behaviours;
}
public static interface ThroughputListener{
public void throughputUpdate(double downThroughput, double upThroughput);
}
}

34
app/src/main/java/com/ericsson/uecontrol/core/behaviour/UeBehaviourDownload.java Executable file
View file

@ -0,0 +1,34 @@
package com.ericsson.uecontrol.core.behaviour;
import com.ericsson.uecontrol.core.UeBehaviour;
/**
* This behaviour simulates streaming data.
* E.g: video, music etc...
*
* Created by ezivkoc on 2014-07-15.
*/
public class UeBehaviourDownload extends UeBehaviour {
private long data_size;
public UeBehaviourDownload(long byte_amount){
data_size = byte_amount;
}
@Override
protected void execute() {
//TODO
}
@Override
public String getName() {
return "Download";
}
@Override
public String toString() {
return "Will download "+ data_size/1000 +"kB";
}
}

46
app/src/main/java/com/ericsson/uecontrol/core/behaviour/UeBehaviourSleep.java Executable file
View file

@ -0,0 +1,46 @@
package com.ericsson.uecontrol.core.behaviour;
import com.ericsson.uecontrol.core.UeBehaviour;
import com.ericsson.uecontrol.gui.util.Configurator.Configurable;
/**
* This behaviour simulates an idle period for the device.
*
* Created by ezivkoc on 2014-07-15.
*/
public class UeBehaviourSleep extends UeBehaviour{
private static final int SLEEP_PERIOD = 100;
@Configurable("Sleep(millisec)")
private int time;
public UeBehaviourSleep(){
this(2000);
}
public UeBehaviourSleep(int milliseconds){
time = milliseconds;
}
@Override
protected void execute() {
int elapsedTime = 0;
while(elapsedTime < time){
super.setProgress((float)elapsedTime/time);
if(super.stopExecution()) break;
try{
Thread.sleep(SLEEP_PERIOD);
}catch(Exception e){e.printStackTrace();};
elapsedTime += SLEEP_PERIOD;
}
}
@Override
public String getName() {
return "Sleep";
}
@Override
public String toString() {
return "Will sleep for "+(time/1000)+" seconds";
}
}

65
app/src/main/java/com/ericsson/uecontrol/core/behaviour/UeBehaviourSurfing.java Executable file
View file

@ -0,0 +1,65 @@
package com.ericsson.uecontrol.core.behaviour;
import com.ericsson.uecontrol.core.UeBehaviour;
import com.ericsson.uecontrol.gui.util.Configurator.Configurable;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.net.URLConnection;
/**
* This behaviour simulates visiting a website
*
* Created by ezivkoc on 2014-07-15.
*/
public class UeBehaviourSurfing extends UeBehaviour {
@Configurable("Web Address")
private String strUrl;
public UeBehaviourSurfing(){
this("http://google.com");
}
public UeBehaviourSurfing(String url){
strUrl = url;
}
@Override
protected void execute() {
try {
URL url = new URL(strUrl);
if(url == null) return;
byte[] data = new byte[100];
URLConnection connection = url.openConnection();
connection.setUseCaches(false);
connection.connect();
InputStream in = connection.getInputStream();
long total = in.available();
long progress = 0;
long read = 0;
while((read = in.read(data)) != -1 && !stopExecution()){
progress += read;
super.setProgress((float)progress/total);
super.setHandledIncomingData(read);
}
} catch (IOException e) {
e.printStackTrace();
}
}
@Override
public String getName() {
return "Surfing";
}
@Override
public String toString() {
return "Will visit "+ strUrl;
}
}

34
app/src/main/java/com/ericsson/uecontrol/core/behaviour/UeBehaviourUpload.java Executable file
View file

@ -0,0 +1,34 @@
package com.ericsson.uecontrol.core.behaviour;
import com.ericsson.uecontrol.core.UeBehaviour;
/**
* This behaviour simulates streaming data.
* E.g: video, music etc...
*
* Created by ezivkoc on 2014-07-15.
*/
public class UeBehaviourUpload extends UeBehaviour {
private long data_size;
public UeBehaviourUpload(long byte_amount){
data_size = byte_amount;
}
@Override
protected void execute() {
//TODO
}
@Override
public String getName() {
return "Upload";
}
@Override
public String toString() {
return "Will Upload "+ data_size/1000 +"kB";
}
}

50
app/src/main/java/com/ericsson/uecontrol/core/util/ThroughputCalculator.java Executable file
View file

@ -0,0 +1,50 @@
package com.ericsson.uecontrol.core.util;
/**
* Created by ezivkoc on 2014-07-22.
*/
public class ThroughputCalculator {
public static final int UPDATES_PER_SEC = 2;
public static final double NANOSEC_PER_SECOND = 1000000000.0;
private boolean updated;
private double throughput;
private long previousTimeStamp;
private long data_amount;
public void setHandledData(long bytes){
long currentTimeStamp = System.nanoTime();
data_amount += bytes;
if(currentTimeStamp - (NANOSEC_PER_SECOND/UPDATES_PER_SEC) > previousTimeStamp) {
throughput = data_amount / ((currentTimeStamp - previousTimeStamp) / (NANOSEC_PER_SECOND/UPDATES_PER_SEC));
previousTimeStamp = currentTimeStamp;
data_amount = 0;
updated = true;
}
}
public double getThroughput(){
setHandledData(0); // Update throughput
updated = false;
return throughput;
}
public boolean isUpdated(){
return updated;
}
private static final String[] DATA_SIZE = new String[]{"b/s", "kbit/s", "Mbit/s", "Gbit/s"};
public static String getThroughputString(double bits){
int index = 0;
double value = bits;
for(; value > 1024 && index < DATA_SIZE.length ;index++) {
value /= 1024;
}
value = (int)(value*10) / 10.0;
return value+" "+DATA_SIZE[index];
}
}

87
app/src/main/java/com/ericsson/uecontrol/gui/EditActivity.java Executable file
View file

@ -0,0 +1,87 @@
package com.ericsson.uecontrol.gui;
import android.app.ListActivity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ListView;
import com.ericsson.uecontrol.R;
import com.ericsson.uecontrol.core.UeBehaviour;
import com.ericsson.uecontrol.core.UeControlExecutor;
import com.ericsson.uecontrol.gui.fragments.SelectBehaviourDialog;
import com.ericsson.uecontrol.gui.util.BehaviourListAdapter;
import com.ericsson.uecontrol.gui.util.DynamicListView;
import java.util.ArrayList;
import java.util.List;
public class EditActivity extends ListActivity implements View.OnClickListener {
private UeControlExecutor executor;
private BehaviourListAdapter adapter;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_edit);
final List<UeBehaviour> list;
if(getIntent().hasExtra("executor")) {
int executorIndex = getIntent().getExtras().getInt("executor_index");
executor = MainActivity.getExecutor(executorIndex);
list = executor.getBehaviourList();
}
else
list = new ArrayList<UeBehaviour>();
adapter = new BehaviourListAdapter(this, list);
adapter.setEditable(true);
DynamicListView listView = (DynamicListView) findViewById(android.R.id.list);
listView.setAdapter(adapter);
listView.setActionListener(adapter);
listView.setOnClickListener(this);
listView.setChoiceMode(ListView.CHOICE_MODE_SINGLE);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.edit, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.action_add) {
SelectBehaviourDialog selector = new SelectBehaviourDialog();
selector.setSelectionCallback(new SelectBehaviourDialog.BehaviourSelectionCallback() {
public void behaviourSelected(String name, Class<UeBehaviour> objClass) {
try {
UeBehaviour obj = objClass.newInstance();
executor.addBehaviour(obj);
adapter.generateIds();
adapter.notifyDataSetChanged();
} catch (Exception e) {
e.printStackTrace();
}
}
});
selector.show(getFragmentManager(), "behaviour_selector");
return true;
}
return super.onOptionsItemSelected(item);
}
@Override
public void onClick(View view) {
}
}

147
app/src/main/java/com/ericsson/uecontrol/gui/MainActivity.java Executable file
View file

@ -0,0 +1,147 @@
package com.ericsson.uecontrol.gui;
import android.app.ActionBar;
import android.app.FragmentManager;
import android.content.Intent;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.support.v4.widget.DrawerLayout;
import android.view.Menu;
import android.view.MenuItem;
import com.ericsson.uecontrol.R;
import com.ericsson.uecontrol.core.UeControlExecutor;
import com.ericsson.uecontrol.core.behaviour.UeBehaviourSleep;
import com.ericsson.uecontrol.core.behaviour.UeBehaviourSurfing;
import com.ericsson.uecontrol.gui.fragments.BehaviourListFragment;
import com.ericsson.uecontrol.gui.fragments.NavigationDrawerFragment;
import com.ericsson.uecontrol.gui.fragments.StatusFragment;
import java.util.ArrayList;
public class MainActivity extends FragmentActivity
implements NavigationDrawerFragment.NavigationDrawerCallbacks {
/**
* Fragment managing the behaviors, interactions and presentation of the navigation drawer.
*/
private NavigationDrawerFragment navigationDrawerFragment;
private StatusFragment statusFragment;
/**
* Used to store the last screen title. For use in {@link #restoreActionBar()}.
*/
private CharSequence title;
private int currentExecutor;
private static ArrayList<UeControlExecutor> executors;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
navigationDrawerFragment = (NavigationDrawerFragment)
getFragmentManager().findFragmentById(R.id.navigation_drawer);
statusFragment = (StatusFragment)
getFragmentManager().findFragmentById(R.id.status_fragment);
title = getTitle();
// Set up the drawer.
navigationDrawerFragment.setUp(
R.id.navigation_drawer,
(DrawerLayout) findViewById(R.id.drawer_layout));
executors = new ArrayList<UeControlExecutor>();
currentExecutor = 0;
UeControlExecutor exec = new UeControlExecutor();
exec.addBehaviour(new UeBehaviourSleep(1000));
exec.addBehaviour(new UeBehaviourSurfing("http://google.com"));
exec.addBehaviour(new UeBehaviourSleep(4000));
exec.setThroughputListener(statusFragment.getThroughputListener());
executors.add(exec);
}
@Override
public void onNavigationDrawerItemSelected(int position) {
// update the main content by replacing fragments
FragmentManager fragmentManager = getFragmentManager();
fragmentManager.beginTransaction()
.replace(R.id.container, BehaviourListFragment.newInstance(position)).commit();
}
public void onSectionAttached(int number) {
currentExecutor = number;
switch (number) {
case 1:
title = getString(R.string.title_section1);
break;
case 2:
title = getString(R.string.title_section2);
break;
case 3:
title = getString(R.string.title_section3);
break;
}
}
public void restoreActionBar() {
ActionBar actionBar = getActionBar();
actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
actionBar.setDisplayShowTitleEnabled(true);
actionBar.setTitle(title);
}
@Override
public boolean onCreateOptionsMenu(Menu menu) {
if (!navigationDrawerFragment.isDrawerOpen()) {
// Only show items in the action bar relevant to this screen
// if the drawer is not showing. Otherwise, let the drawer
// decide what to show in the action bar.
getMenuInflater().inflate(R.menu.main, menu);
restoreActionBar();
return true;
}
return super.onCreateOptionsMenu(menu);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Handle action bar item clicks here. The action bar will
// automatically handle clicks on the Home/Up button, so long
// as you specify a parent activity in AndroidManifest.xml.
int id = item.getItemId();
if (id == R.id.action_execute) {
UeControlExecutor exec = executors.get(currentExecutor);
if(exec.isRunning()){
exec.terminate();
item.setTitle(R.string.action_run);
}
else {
exec.execute();
item.setTitle(R.string.action_stop);
}
return true;
}
if (id == R.id.action_edit) {
Intent intent = new Intent(this, EditActivity.class);
intent.putExtra("executor", currentExecutor);
startActivity(intent);
return true;
}
if (id == R.id.action_settings) {
startActivity(new Intent(this, SettingsActivity.class));
return true;
}
return super.onOptionsItemSelected(item);
}
public static UeControlExecutor getExecutor(int index) {
if(index >= executors.size())
return null;
return executors.get(index);
}
}

31
app/src/main/java/com/ericsson/uecontrol/gui/SettingsActivity.java Executable file
View file

@ -0,0 +1,31 @@
package com.ericsson.uecontrol.gui;
import android.app.Activity;
import android.os.Bundle;
import android.preference.PreferenceFragment;
import com.ericsson.uecontrol.R;
public class SettingsActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Display the fragment as the main content.
getFragmentManager().beginTransaction()
.replace(android.R.id.content, new SettingsFragment())
.commit();
}
public static class SettingsFragment extends PreferenceFragment {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Load the preferences from an XML resource
addPreferencesFromResource(R.xml.preferences);
}
}
}

104
app/src/main/java/com/ericsson/uecontrol/gui/fragments/BehaviourListFragment.java Executable file
View file

@ -0,0 +1,104 @@
package com.ericsson.uecontrol.gui.fragments;
import android.app.Fragment;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AbsListView;
import android.widget.AdapterView;
import android.widget.TextView;
import com.ericsson.uecontrol.R;
import com.ericsson.uecontrol.core.UeControlExecutor;
import com.ericsson.uecontrol.gui.MainActivity;
import com.ericsson.uecontrol.gui.util.BehaviourListAdapter;
import java.util.ArrayList;
/**
* This fragment will show a read only list of defined UeBehaviours
*/
public class BehaviourListFragment extends Fragment implements AbsListView.OnItemClickListener {
/**
* The fragment's ListView/GridView.
*/
private AdapterView listView;
/**
* The Adapter which will be used to populate the ListView/GridView with
* Views.
*/
private BehaviourListAdapter adapter;
private UeControlExecutor executor;
public static BehaviourListFragment newInstance(int index) {
BehaviourListFragment f = new BehaviourListFragment();
// Supply index input as an argument.
Bundle args = new Bundle();
args.putInt("executor", index);
f.setArguments(args);
return f;
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
Bundle args = getArguments();
int index = args.getInt("executor", 0);
if(MainActivity.getExecutor(index) != null) {
UeControlExecutor executor = MainActivity.getExecutor(index);
adapter = new BehaviourListAdapter(getActivity(), executor.getBehaviourList());
}
else
adapter = new BehaviourListAdapter(getActivity(), new ArrayList());
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
View view = inflater.inflate(R.layout.fragment_item, container, false);
// Set the adapter
listView = (AdapterView) view.findViewById(android.R.id.list);
listView.setAdapter(adapter);
// Set OnItemClickListener so we can be notified on item clicks
//listView.setOnItemClickListener(this);
setEmptyText("No Behaviours Defined");
return view;
}
@Override
public void onResume() {
adapter.generateIds();
adapter.notifyDataSetChanged();
super.onResume();
}
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
}
/**
* The default content for this Fragment has a TextView that is shown when
* the list is empty. If you would like to change the text, call this method
* to supply the text it should use.
*/
public void setEmptyText(CharSequence emptyText) {
View emptyView = listView.getEmptyView();
if (emptyText instanceof TextView) {
((TextView) emptyView).setText(emptyText);
}
}
}

45
app/src/main/java/com/ericsson/uecontrol/gui/fragments/ConfigureBehaviourDialog.java Executable file
View file

@ -0,0 +1,45 @@
package com.ericsson.uecontrol.gui.fragments;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;
import android.os.Bundle;
import android.widget.EditText;
import android.widget.LinearLayout;
import android.widget.TextView;
import com.ericsson.uecontrol.R;
/**
* Created by ezivkoc on 2014-07-24.
*/
public class ConfigureBehaviourDialog extends DialogFragment {
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
// Create dialog
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setTitle(R.string.configure_behaviour);
builder.setPositiveButton(R.string.action_save, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
// User clicked OK button
}
});
builder.setNegativeButton(R.string.action_cancel, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {}
});
LinearLayout root = new LinearLayout(getActivity());
LinearLayout param = new LinearLayout(getActivity());
param.addView(new TextView(getActivity()));
param.addView(new EditText(getActivity()));
root.addView(param);
builder.setView(root);
return builder.create();
}
}

284
app/src/main/java/com/ericsson/uecontrol/gui/fragments/NavigationDrawerFragment.java Executable file
View file

@ -0,0 +1,284 @@
package com.ericsson.uecontrol.gui.fragments;
import android.app.ActionBar;
import android.app.Activity;
import android.app.Fragment;
import android.content.SharedPreferences;
import android.content.res.Configuration;
import android.os.Bundle;
import android.preference.PreferenceManager;
import android.support.v4.app.ActionBarDrawerToggle;
import android.support.v4.view.GravityCompat;
import android.support.v4.widget.DrawerLayout;
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.widget.AdapterView;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;
import com.ericsson.uecontrol.R;
/**
* Fragment used for managing interactions for and presentation of a navigation drawer.
* See the <a href="https://developer.android.com/design/patterns/navigation-drawer.html#Interaction">
* design guidelines</a> for a complete explanation of the behaviors implemented here.
*/
public class NavigationDrawerFragment extends Fragment {
/**
* Remember the position of the selected item.
*/
private static final String STATE_SELECTED_POSITION = "selected_navigation_drawer_position";
/**
* Per the design guidelines, you should show the drawer on launch until the user manually
* expands it. This shared preference tracks this.
*/
private static final String PREF_USER_LEARNED_DRAWER = "navigation_drawer_learned";
/**
* A pointer to the current callbacks instance (the Activity).
*/
private NavigationDrawerCallbacks mCallbacks;
/**
* Helper component that ties the action bar to the navigation drawer.
*/
private ActionBarDrawerToggle mDrawerToggle;
private DrawerLayout mDrawerLayout;
private ListView mDrawerListView;
private View mFragmentContainerView;
private int mCurrentSelectedPosition = 0;
private boolean mFromSavedInstanceState;
private boolean mUserLearnedDrawer;
public NavigationDrawerFragment() {
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
// Read in the flag indicating whether or not the user has demonstrated awareness of the
// drawer. See PREF_USER_LEARNED_DRAWER for details.
SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(getActivity());
mUserLearnedDrawer = sp.getBoolean(PREF_USER_LEARNED_DRAWER, false);
if (savedInstanceState != null) {
mCurrentSelectedPosition = savedInstanceState.getInt(STATE_SELECTED_POSITION);
mFromSavedInstanceState = true;
}
// Select either the default item (0) or the last selected item.
selectItem(mCurrentSelectedPosition);
}
@Override
public void onActivityCreated (Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
// Indicate that this fragment would like to influence the set of actions in the action bar.
setHasOptionsMenu(true);
}
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
mDrawerListView = (ListView) inflater.inflate(
R.layout.fragment_navigation_drawer, container, false);
mDrawerListView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
selectItem(position);
}
});
mDrawerListView.setAdapter(new ArrayAdapter<String>(
getActionBar().getThemedContext(),
android.R.layout.simple_list_item_activated_1,
android.R.id.text1,
new String[]{
getString(R.string.title_section1),
getString(R.string.title_section2),
getString(R.string.title_section3),
}));
mDrawerListView.setItemChecked(mCurrentSelectedPosition, true);
return mDrawerListView;
}
public boolean isDrawerOpen() {
return mDrawerLayout != null && mDrawerLayout.isDrawerOpen(mFragmentContainerView);
}
/**
* Users of this fragment must call this method to set up the navigation drawer interactions.
*
* @param fragmentId The android:id of this fragment in its activity's layout.
* @param drawerLayout The DrawerLayout containing this fragment's UI.
*/
public void setUp(int fragmentId, DrawerLayout drawerLayout) {
mFragmentContainerView = getActivity().findViewById(fragmentId);
mDrawerLayout = drawerLayout;
// set a custom shadow that overlays the main content when the drawer opens
mDrawerLayout.setDrawerShadow(R.drawable.drawer_shadow, GravityCompat.START);
// set up the drawer's list view with items and click listener
ActionBar actionBar = getActionBar();
actionBar.setDisplayHomeAsUpEnabled(true);
actionBar.setHomeButtonEnabled(true);
// ActionBarDrawerToggle ties together the the proper interactions
// between the navigation drawer and the action bar app icon.
mDrawerToggle = new ActionBarDrawerToggle(
getActivity(), /* host Activity */
mDrawerLayout, /* DrawerLayout object */
R.drawable.ic_drawer, /* nav drawer image to replace 'Up' caret */
R.string.navigation_drawer_open, /* "open drawer" description for accessibility */
R.string.navigation_drawer_close /* "close drawer" description for accessibility */
) {
@Override
public void onDrawerClosed(View drawerView) {
super.onDrawerClosed(drawerView);
if (!isAdded()) {
return;
}
getActivity().invalidateOptionsMenu(); // calls onPrepareOptionsMenu()
}
@Override
public void onDrawerOpened(View drawerView) {
super.onDrawerOpened(drawerView);
if (!isAdded()) {
return;
}
if (!mUserLearnedDrawer) {
// The user manually opened the drawer; store this flag to prevent auto-showing
// the navigation drawer automatically in the future.
mUserLearnedDrawer = true;
SharedPreferences sp = PreferenceManager
.getDefaultSharedPreferences(getActivity());
sp.edit().putBoolean(PREF_USER_LEARNED_DRAWER, true).apply();
}
getActivity().invalidateOptionsMenu(); // calls onPrepareOptionsMenu()
}
};
// If the user hasn't 'learned' about the drawer, open it to introduce them to the drawer,
// per the navigation drawer design guidelines.
if (!mUserLearnedDrawer && !mFromSavedInstanceState) {
mDrawerLayout.openDrawer(mFragmentContainerView);
}
// Defer code dependent on restoration of previous instance state.
mDrawerLayout.post(new Runnable() {
@Override
public void run() {
mDrawerToggle.syncState();
}
});
mDrawerLayout.setDrawerListener(mDrawerToggle);
}
private void selectItem(int position) {
mCurrentSelectedPosition = position;
if (mDrawerListView != null) {
mDrawerListView.setItemChecked(position, true);
}
if (mDrawerLayout != null) {
mDrawerLayout.closeDrawer(mFragmentContainerView);
}
if (mCallbacks != null) {
mCallbacks.onNavigationDrawerItemSelected(position);
}
}
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
try {
mCallbacks = (NavigationDrawerCallbacks) activity;
} catch (ClassCastException e) {
throw new ClassCastException("Activity must implement NavigationDrawerCallbacks.");
}
}
@Override
public void onDetach() {
super.onDetach();
mCallbacks = null;
}
@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
outState.putInt(STATE_SELECTED_POSITION, mCurrentSelectedPosition);
}
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
// Forward the new configuration the drawer toggle component.
mDrawerToggle.onConfigurationChanged(newConfig);
}
@Override
public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
// If the drawer is open, show the global app actions in the action bar. See also
// showGlobalContextActionBar, which controls the top-left area of the action bar.
if (mDrawerLayout != null && isDrawerOpen()) {
inflater.inflate(R.menu.global, menu);
showGlobalContextActionBar();
}
super.onCreateOptionsMenu(menu, inflater);
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
if (mDrawerToggle.onOptionsItemSelected(item)) {
return true;
}
if (item.getItemId() == R.id.action_execute) {
Toast.makeText(getActivity(), "Running", Toast.LENGTH_SHORT).show();
return true;
}
return super.onOptionsItemSelected(item);
}
/**
* Per the navigation drawer design guidelines, updates the action bar to show the global app
* 'context', rather than just what's in the current screen.
*/
private void showGlobalContextActionBar() {
ActionBar actionBar = getActionBar();
actionBar.setDisplayShowTitleEnabled(true);
actionBar.setNavigationMode(ActionBar.NAVIGATION_MODE_STANDARD);
actionBar.setTitle(R.string.app_name);
}
private ActionBar getActionBar() {
return getActivity().getActionBar();
}
/**
* Callbacks interface that all activities using this fragment must implement.
*/
public static interface NavigationDrawerCallbacks {
/**
* Called when an item in the navigation drawer is selected.
*/
void onNavigationDrawerItemSelected(int position);
}
}

64
app/src/main/java/com/ericsson/uecontrol/gui/fragments/SelectBehaviourDialog.java Executable file
View file

@ -0,0 +1,64 @@
package com.ericsson.uecontrol.gui.fragments;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.DialogFragment;
import android.content.DialogInterface;
import android.os.Bundle;
import com.ericsson.uecontrol.R;
import com.ericsson.uecontrol.core.UeBehaviour;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class SelectBehaviourDialog extends DialogFragment {
public static String[] behavioursClasses;
public static String[] behaviourNames;
private BehaviourSelectionCallback callback;
@Override
public Dialog onCreateDialog(Bundle savedInstanceState) {
// Generate nice behaviour names
if(behavioursClasses == null) {
behavioursClasses = getResources().getStringArray(R.array.behaviours);
behaviourNames = new String[behavioursClasses.length];
Pattern p = Pattern.compile("[\\w\\.]*\\.(?:UeBehaviour|)(\\w*)");
for (int i = 0; i < behavioursClasses.length; i++) {
Matcher m = p.matcher(behavioursClasses[i]);
if(m.find())
behaviourNames[i] = m.group(1);
else
behaviourNames[i] = behavioursClasses[i];
}
}
// Create dialog
AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
builder.setTitle(R.string.select_behaviour);
builder.setItems(behaviourNames, new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int which) {
try {
if (callback != null){
Class objClass = Class.forName(behavioursClasses[which]);
callback.behaviourSelected(behaviourNames[which], objClass);
}
} catch (Exception e) {
e.printStackTrace();
}
}
});
return builder.create();
}
public void setSelectionCallback(BehaviourSelectionCallback c){
callback = c;
}
public static interface BehaviourSelectionCallback{
public void behaviourSelected(String name, Class<UeBehaviour> objClass);
}
}

82
app/src/main/java/com/ericsson/uecontrol/gui/fragments/StatusFragment.java Executable file
View file

@ -0,0 +1,82 @@
package com.ericsson.uecontrol.gui.fragments;
import android.app.Fragment;
import android.graphics.Color;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.LinearLayout;
import android.widget.LinearLayout.LayoutParams;
import android.widget.TextView;
import com.ericsson.uecontrol.R;
import com.ericsson.uecontrol.core.UeControlExecutor;
import com.ericsson.uecontrol.core.util.ThroughputCalculator;
import com.jjoe64.graphview.GraphView.GraphViewData;
import com.jjoe64.graphview.GraphViewSeries;
import com.jjoe64.graphview.GraphViewSeries.GraphViewSeriesStyle;
import com.jjoe64.graphview.GraphViewStyle;
import com.jjoe64.graphview.LineGraphView;
/**
* Created by ezivkoc on 2014-07-15.
*/
public class StatusFragment extends Fragment {
private TextView down_speed;
private TextView up_speed;
private GraphViewSeries downGraph;
private GraphViewSeries upGraph;
private int x = 0;
@Override
public View onCreateView(LayoutInflater inflater, ViewGroup container,
Bundle savedInstanceState) {
// Inflate the layout for this fragment
View view = inflater.inflate(R.layout.fragment_status, container, false);
down_speed = (TextView) view.findViewById(R.id.down_speed);
up_speed = (TextView) view.findViewById(R.id.up_speed);
// Init the graph
GraphViewData[] zeroPoint = new GraphViewData[]{new GraphViewData(0, 0)};
downGraph = new GraphViewSeries("Download Throughput", new GraphViewSeriesStyle(Color.GREEN, 3), zeroPoint);
upGraph = new GraphViewSeries("Upload Throughput" , new GraphViewSeriesStyle(Color.RED , 3), zeroPoint);
LineGraphView graphView = new LineGraphView(this.getActivity(), "GraphViewDemo");
graphView.addSeries(downGraph);
graphView.addSeries(upGraph);
//graphView.setDrawDataPoints(true);
graphView.setScrollable(true);
graphView.setViewPort(0, 120);
graphView.setLayoutParams(new LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.MATCH_PARENT));
graphView.getGraphViewStyle().setGridStyle(GraphViewStyle.GridStyle.BOTH);
LinearLayout layout = (LinearLayout) view.findViewById(R.id.graph);
layout.addView(graphView);
return view;
}
private UeControlExecutor.ThroughputListener throughputListener =
new UeControlExecutor.ThroughputListener() {
public void throughputUpdate(final double downThroughput, final double upThroughput) {
if(down_speed != null && up_speed != null)
down_speed.post(new Runnable() {
@Override
public void run() {
down_speed.setText(ThroughputCalculator.getThroughputString(downThroughput));
up_speed.setText(ThroughputCalculator.getThroughputString(upThroughput));
downGraph.appendData(new GraphViewData(x, downThroughput), true, 120);
upGraph.appendData(new GraphViewData(x, upThroughput), true, 120);
x++;
}
});
}
};
public UeControlExecutor.ThroughputListener getThroughputListener(){
return throughputListener;
}
}

82
app/src/main/java/com/ericsson/uecontrol/gui/util/BehaviourListAdapter.java Executable file
View file

@ -0,0 +1,82 @@
package com.ericsson.uecontrol.gui.util;
import android.app.Activity;
import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.ProgressBar;
import android.widget.TextView;
import com.ericsson.uecontrol.R;
import com.ericsson.uecontrol.core.UeBehaviour;
import java.util.List;
/**
* Created by ezivkoc on 2014-07-15.
*/
public class BehaviourListAdapter extends StableArrayAdapter<UeBehaviour>{
private static final int VIEW_RESOURCE = R.layout.behaviour_list_item;
private static LayoutInflater inflater = null;
private boolean editable = false;
public BehaviourListAdapter(Activity a, List<UeBehaviour> objects) {
super(a, VIEW_RESOURCE, objects);
inflater = (LayoutInflater)a.getSystemService(Context.LAYOUT_INFLATER_SERVICE);
}
public View getView(int position, View convertView, ViewGroup parent) {
View vi = convertView;
if(convertView==null)
vi = inflater.inflate(VIEW_RESOURCE, null);
ImageView draggable = (ImageView)vi.findViewById(R.id.draggable);
TextView title = (TextView)vi.findViewById(R.id.title);
TextView description = (TextView)vi.findViewById(R.id.description);
final ProgressBar active = (ProgressBar)vi.findViewById(R.id.active);
final ProgressBar progress = (ProgressBar) vi.findViewById(R.id.progress);
UeBehaviour behaviour = super.getItem(position);
// Setting all values in listview
title.setText(behaviour.getName());
description.setText(behaviour.toString());
if(editable)
draggable.setVisibility(View.VISIBLE);
behaviour.setExecutionListener(new UeBehaviour.BehaviourExecutionListener() {
public void executionStarted() {
progress.post(new Runnable() {
public void run() {
active.setVisibility(View.VISIBLE);
progress.setVisibility(View.VISIBLE);
}
});
}
public void progressChanged(final float p) {
progress.setMax(100);
progress.setProgress((int) (p * 100));
}
public void executionStopped() {
progress.post(new Runnable() {
public void run() {
active.setVisibility(View.INVISIBLE);
progress.setVisibility(View.INVISIBLE);
}
});
}
});
return vi;
}
public void setEditable(boolean b) {
editable = b;
}
}

68
app/src/main/java/com/ericsson/uecontrol/gui/util/Configurator.java Executable file
View file

@ -0,0 +1,68 @@
package com.ericsson.uecontrol.gui.util;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
/**
* Created by ezivkoc on 2014-07-24.
*/
public class Configurator {
/**
* Sets a field in a class as externally configurable.
*/
@Retention(RetentionPolicy.RUNTIME) // Make this annotation accessible at runtime via reflection.
@Target({ElementType.FIELD}) // This annotation can only be applied to class fields.
public static @interface Configurable{
String value();
}
public static enum ConfigType{
STRING, INT
}
public static class ConfigurationParam{
protected Field field;
protected ConfigType type;
protected Object value;
public ConfigType getType(){return type;}
public int getInt (){return (Integer) value;}
public String setString(){return (String) value;}
public void setInt (int v) {value = v;}
public void setString(String v){value = v;}
}
public static ConfigurationParam[] getConfiguration(Class c){
ArrayList<ConfigurationParam> conf = new ArrayList<ConfigurationParam>();
Field[] all = c.getFields();
for(Field f : all){
if(f.isAnnotationPresent(Configurable.class) && !Modifier.isStatic(f.getModifiers())) {
ConfigurationParam confParam = new ConfigurationParam();
confParam.field = f;
conf.add(confParam);
}
}
return (ConfigurationParam[])conf.toArray();
}
public static void setConfiguration(ConfigurationParam[] params, Object obj){
for(ConfigurationParam param : params){
try {
param.field.setAccessible(true);
param.field.set(obj, param.value);
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
}
}

620
app/src/main/java/com/ericsson/uecontrol/gui/util/DynamicListView.java Executable file
View file

@ -0,0 +1,620 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.ericsson.uecontrol.gui.util;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.animation.ObjectAnimator;
import android.animation.TypeEvaluator;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.util.AttributeSet;
import android.util.DisplayMetrics;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewTreeObserver;
import android.widget.AbsListView;
import android.widget.ListAdapter;
import android.widget.ListView;
/**
* The dynamic listview is an extension of listview that supports cell dragging
* and swapping.
* <p/>
* This layout is in charge of positioning the hover cell in the correct location
* on the screen in response to user touch events. It uses the position of the
* hover cell to determine when two cells should be swapped. If two cells should
* be swapped, all the corresponding data set and layout changes are handled here.
* <p/>
* If no cell is selected, all the touch events are passed down to the listview
* and behave normally. If one of the items in the listview experiences a
* long press event, the contents of its current visible state are captured as
* a bitmap and its visibility is set to INVISIBLE. A hover cell is then created and
* added to this layout as an overlaying BitmapDrawable above the listview. Once the
* hover cell is translated some distance to signify an item swap, a data set change
* accompanied by animation takes place. When the user releases the hover cell,
* it animates into its corresponding position in the listview.
* <p/>
* When the hover cell is either above or below the bounds of the listview, this
* listview also scrolls on its own so as to reveal additional content.
*/
public class DynamicListView extends ListView {
private static final int INVALID_POINTER_ID = -1;
private static final int INVALID_ID = -1;
private static final int SMOOTH_SCROLL_AMOUNT_AT_EDGE = 15;
private static final int MOVE_DURATION = 150;
private static final int LINE_THICKNESS = 15;
private static final int REMOVE_OFFSET = 150;
private static final int SWAP_OFFSET = 130;
private static enum TouchMode {UNKNOWN, REMOVE, SWAP};
private int mDownY = -1;
private int mDownX = -1;
private int mLastEventX = -1;
private int mLastEventY = -1;
private int mTotalOffset = 0;
private boolean mCellIsMobile = false;
private boolean mIsMobileScrolling = false;
private int mSmoothScrollAmountAtEdge = 0;
private long mAboveItemId = INVALID_ID;
private long mMobileItemId = INVALID_ID;
private long mBelowItemId = INVALID_ID;
private BitmapDrawable mHoverCell;
private TouchMode mMode;
private Rect mHoverCellCurrentBounds;
private Rect mHoverCellOriginalBounds;
private int mActivePointerId = INVALID_POINTER_ID;
private boolean mIsWaitingForScrollFinish = false;
private int mScrollState = OnScrollListener.SCROLL_STATE_IDLE;
private DynamicListActionListener listener;
public DynamicListView(Context context) {
super(context);
init(context);
}
public DynamicListView(Context context, AttributeSet attrs) {
super(context, attrs);
init(context);
}
public DynamicListView(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init(context);
}
public void init(Context context) {
setOnScrollListener(mScrollListener);
DisplayMetrics metrics = context.getResources().getDisplayMetrics();
mSmoothScrollAmountAtEdge = (int) (SMOOTH_SCROLL_AMOUNT_AT_EDGE / metrics.density);
}
public void setActionListener(DynamicListActionListener l){
listener = l;
}
protected void startItemHover(){
mTotalOffset = 0;
int position = pointToPosition(mDownX, mDownY);
int itemNum = position - getFirstVisiblePosition();
View selectedView = getChildAt(itemNum);
if(selectedView != null) {
mMobileItemId = getAdapter().getItemId(position);
mHoverCell = getAndAddHoverView(selectedView);
selectedView.setVisibility(INVISIBLE);
mCellIsMobile = true;
updateNeighborViewsForID(mMobileItemId);
}
}
/**
* Creates the hover cell with the appropriate bitmap and of appropriate
* size. The hover cell's BitmapDrawable is drawn on top of the bitmap every
* single time an invalidate call is made.
*/
private BitmapDrawable getAndAddHoverView(View v) {
int w = v.getWidth();
int h = v.getHeight();
int top = v.getTop();
int left = v.getLeft();
mHoverCellOriginalBounds = new Rect(left, top, left + w, top + h);
mHoverCellCurrentBounds = new Rect(mHoverCellOriginalBounds);
BitmapDrawable drawable = new BitmapDrawable(getResources(), getBitmapWithBorder(v));
drawable.setBounds(mHoverCellCurrentBounds);
return drawable;
}
/**
* Draws a black border over the screenshot of the view passed in.
*/
private Bitmap getBitmapWithBorder(View v) {
Bitmap bitmap = Bitmap.createBitmap(v.getWidth(), v.getHeight(), Bitmap.Config.ARGB_8888);
Canvas canvas = new Canvas(bitmap);
v.draw(canvas);
addBorder(bitmap, Color.BLACK);
return bitmap;
}
private void addBorder(Bitmap b, int color){
Paint paint = new Paint();
paint.setStyle(Paint.Style.STROKE);
paint.setStrokeWidth(LINE_THICKNESS);
paint.setColor(color);
Canvas canvas = new Canvas(b);
canvas.drawRect(new Rect(0, 0, b.getWidth(), b.getHeight()), paint);
}
/**
* Stores a reference to the views above and below the item currently
* corresponding to the hover cell. It is important to note that if this
* item is either at the top or bottom of the list, mAboveItemId or mBelowItemId
* may be invalid.
*/
private void updateNeighborViewsForID(long itemID) {
int position = getPositionForID(itemID);
ListAdapter adapter = getAdapter();
mAboveItemId = adapter.getItemId(position - 1);
mBelowItemId = adapter.getItemId(position + 1);
}
/**
* Retrieves the view in the list corresponding to itemID
*/
public View getViewForID(long itemID) {
int firstVisiblePosition = getFirstVisiblePosition();
ListAdapter adapter = getAdapter();
for (int i = 0; i < getChildCount(); i++) {
View v = getChildAt(i);
int position = firstVisiblePosition + i;
long id = adapter.getItemId(position);
if (id == itemID) {
return v;
}
}
return null;
}
/**
* Retrieves the position in the list corresponding to itemID
*/
public int getPositionForID(long itemID) {
View v = getViewForID(itemID);
if (v == null) {
return -1;
} else {
return getPositionForView(v);
}
}
/**
* dispatchDraw gets invoked when all the child views are about to be drawn.
* By overriding this method, the hover cell (BitmapDrawable) can be drawn
* over the listview's items whenever the listview is redrawn.
*/
@Override
protected void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
if (mHoverCell != null) {
mHoverCell.draw(canvas);
}
}
@Override
public boolean onTouchEvent(MotionEvent event) {
if(listener != null) {
switch (event.getAction() & MotionEvent.ACTION_MASK) {
case MotionEvent.ACTION_DOWN:
mDownX = (int) event.getX();
mDownY = (int) event.getY();
mActivePointerId = event.getPointerId(0);
mMode = TouchMode.UNKNOWN;
break;
case MotionEvent.ACTION_MOVE:
if (mActivePointerId == INVALID_POINTER_ID) {
break;
}
int pointerIndex = event.findPointerIndex(mActivePointerId);
mLastEventX = (int) event.getX(pointerIndex);
mLastEventY = (int) event.getY(pointerIndex);
int deltaX = mLastEventX - mDownX;
int deltaY = mLastEventY - mDownY;
if (mMode == TouchMode.UNKNOWN) {
if (Math.abs(deltaX) > 50 || Math.abs(deltaY) > 50) {
if (Math.abs(deltaX) >= Math.abs(deltaY))
mMode = TouchMode.REMOVE;
if (Math.abs(deltaX) < Math.abs(deltaY) && mDownX < SWAP_OFFSET)
mMode = TouchMode.SWAP;
if (mMode != TouchMode.UNKNOWN)
startItemHover();
}
}
if (mMode == TouchMode.REMOVE) {
mHoverCellCurrentBounds.offsetTo(mHoverCellOriginalBounds.left + deltaX,
mHoverCellOriginalBounds.top);
mHoverCell.setBounds(mHoverCellCurrentBounds);
if(mLastEventX + REMOVE_OFFSET > this.getRight())
addBorder(mHoverCell.getBitmap(), Color.RED);
else
addBorder(mHoverCell.getBitmap(), Color.BLACK);
invalidate();
} else if (mMode == TouchMode.SWAP) {
if (mCellIsMobile) {
mHoverCellCurrentBounds.offsetTo(mHoverCellOriginalBounds.left,
mHoverCellOriginalBounds.top + deltaY + mTotalOffset);
mHoverCell.setBounds(mHoverCellCurrentBounds);
invalidate();
handleCellSwitch();
mIsMobileScrolling = false;
handleMobileCellScroll();
return false;
}
}
break;
case MotionEvent.ACTION_UP:
touchEventsEnded();
break;
case MotionEvent.ACTION_CANCEL:
touchEventsCancelled();
break;
case MotionEvent.ACTION_POINTER_UP:
/* If a multitouch event took place and the original touch dictating
* the movement of the hover cell has ended, then the dragging event
* ends and the hover cell is animated to its corresponding position
* in the listview. */
pointerIndex = (event.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK) >>
MotionEvent.ACTION_POINTER_INDEX_SHIFT;
final int pointerId = event.getPointerId(pointerIndex);
if (pointerId == mActivePointerId) {
touchEventsEnded();
}
break;
default:
break;
}
}
return super.onTouchEvent(event);
}
/**
* This method determines whether the hover cell has been shifted far enough
* to invoke a cell swap. If so, then the respective cell swap candidate is
* determined and the data set is changed. Upon posting a notification of the
* data set change, a layout is invoked to place the cells in the right place.
* Using a ViewTreeObserver and a corresponding OnPreDrawListener, we can
* offset the cell being swapped to where it previously was and then animate it to
* its new position.
*/
private void handleCellSwitch() {
final int deltaY = mLastEventY - mDownY;
int deltaYTotal = mHoverCellOriginalBounds.top + mTotalOffset + deltaY;
View belowView = getViewForID(mBelowItemId);
View mobileView = getViewForID(mMobileItemId);
View aboveView = getViewForID(mAboveItemId);
boolean isBelow = (belowView != null) && (deltaYTotal > belowView.getTop());
boolean isAbove = (aboveView != null) && (deltaYTotal < aboveView.getTop());
if (isBelow || isAbove) {
final long switchItemID = isBelow ? mBelowItemId : mAboveItemId;
View switchView = isBelow ? belowView : aboveView;
final int originalItem = getPositionForView(mobileView);
if (switchView == null) {
updateNeighborViewsForID(mMobileItemId);
return;
}
listener.swapItems(originalItem, getPositionForView(switchView));
((StableArrayAdapter) getAdapter()).notifyDataSetChanged();
mDownY = mLastEventY;
mobileView.setVisibility(View.VISIBLE);
switchView.setVisibility(View.INVISIBLE);
updateNeighborViewsForID(mMobileItemId);
final int switchViewStartTop = switchView.getTop();
final ViewTreeObserver observer = getViewTreeObserver();
observer.addOnPreDrawListener(new ViewTreeObserver.OnPreDrawListener() {
public boolean onPreDraw() {
observer.removeOnPreDrawListener(this);
View switchView = getViewForID(switchItemID);
mTotalOffset += deltaY;
int switchViewNewTop = switchView.getTop();
int delta = switchViewStartTop - switchViewNewTop;
switchView.setTranslationY(delta);
ObjectAnimator animator = ObjectAnimator.ofFloat(switchView,
View.TRANSLATION_Y, 0);
animator.setDuration(MOVE_DURATION);
animator.start();
return true;
}
});
}
}
/**
* Resets all the appropriate fields to a default state while also animating
* the hover cell back to its correct location.
*/
private void touchEventsEnded() {
final View mobileView = getViewForID(mMobileItemId);
if (mCellIsMobile || mIsWaitingForScrollFinish) {
mCellIsMobile = false;
mIsWaitingForScrollFinish = false;
mIsMobileScrolling = false;
mActivePointerId = INVALID_POINTER_ID;
// If the autoscroller has not completed scrolling, we need to wait for it to
// finish in order to determine the final location of where the hover cell
// should be animated to.
if (mScrollState != OnScrollListener.SCROLL_STATE_IDLE) {
mIsWaitingForScrollFinish = true;
return;
}
if(mMode == TouchMode.REMOVE) {
if (mLastEventX + REMOVE_OFFSET > mobileView.getRight()) {
listener.removeItem(getPositionForView(mobileView));
((StableArrayAdapter) getAdapter()).notifyDataSetChanged();
mHoverCellCurrentBounds.offsetTo(this.getRight(), mHoverCellCurrentBounds.top);
}
else // reset
mHoverCellCurrentBounds.offsetTo(mHoverCellOriginalBounds.left, mobileView.getTop());
}
else if(mMode == TouchMode.SWAP) {
mHoverCellCurrentBounds.offsetTo(mHoverCellOriginalBounds.left, mobileView.getTop());
}
// Animate
ObjectAnimator hoverViewAnimator = ObjectAnimator.ofObject(mHoverCell, "bounds",
sBoundEvaluator, mHoverCellCurrentBounds);
hoverViewAnimator.addUpdateListener(new ValueAnimator.AnimatorUpdateListener() {
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator) {
invalidate();
}
});
hoverViewAnimator.addListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationStart(Animator animation) {
setEnabled(false);
}
@Override
public void onAnimationEnd(Animator animation) {
mAboveItemId = INVALID_ID;
mMobileItemId = INVALID_ID;
mBelowItemId = INVALID_ID;
mobileView.setVisibility(VISIBLE);
mHoverCell = null;
setEnabled(true);
invalidate();
}
});
hoverViewAnimator.start();
} else {
touchEventsCancelled();
}
}
/**
* Resets all the appropriate fields to a default state.
*/
private void touchEventsCancelled() {
View mobileView = getViewForID(mMobileItemId);
if (mCellIsMobile) {
mAboveItemId = INVALID_ID;
mMobileItemId = INVALID_ID;
mBelowItemId = INVALID_ID;
mobileView.setVisibility(VISIBLE);
mHoverCell = null;
invalidate();
}
mCellIsMobile = false;
mIsMobileScrolling = false;
mActivePointerId = INVALID_POINTER_ID;
}
/**
* This TypeEvaluator is used to animate the BitmapDrawable back to its
* final location when the user lifts his finger by modifying the
* BitmapDrawable's bounds.
*/
private final static TypeEvaluator<Rect> sBoundEvaluator = new TypeEvaluator<Rect>() {
public Rect evaluate(float fraction, Rect startValue, Rect endValue) {
return new Rect(interpolate(startValue.left, endValue.left, fraction),
interpolate(startValue.top, endValue.top, fraction),
interpolate(startValue.right, endValue.right, fraction),
interpolate(startValue.bottom, endValue.bottom, fraction));
}
public int interpolate(int start, int end, float fraction) {
return (int) (start + fraction * (end - start));
}
};
/**
* Determines whether this listview is in a scrolling state invoked
* by the fact that the hover cell is out of the bounds of the listview;
*/
private void handleMobileCellScroll() {
mIsMobileScrolling = handleMobileCellScroll(mHoverCellCurrentBounds);
}
/**
* This method is in charge of determining if the hover cell is above
* or below the bounds of the listview. If so, the listview does an appropriate
* upward or downward smooth scroll so as to reveal new items.
*/
public boolean handleMobileCellScroll(Rect r) {
int offset = computeVerticalScrollOffset();
int height = getHeight();
int extent = computeVerticalScrollExtent();
int range = computeVerticalScrollRange();
int hoverViewTop = r.top;
int hoverHeight = r.height();
if (hoverViewTop <= 0 && offset > 0) {
smoothScrollBy(-mSmoothScrollAmountAtEdge, 0);
return true;
}
if (hoverViewTop + hoverHeight >= height && (offset + extent) < range) {
smoothScrollBy(mSmoothScrollAmountAtEdge, 0);
return true;
}
return false;
}
/**
* This scroll listener is added to the listview in order to handle cell swapping
* when the cell is either at the top or bottom edge of the listview. If the hover
* cell is at either edge of the listview, the listview will begin scrolling. As
* scrolling takes place, the listview continuously checks if new cells became visible
* and determines whether they are potential candidates for a cell swap.
*/
private AbsListView.OnScrollListener mScrollListener = new AbsListView.OnScrollListener() {
private int mPreviousFirstVisibleItem = -1;
private int mPreviousVisibleItemCount = -1;
private int mCurrentFirstVisibleItem;
private int mCurrentVisibleItemCount;
private int mCurrentScrollState;
public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
int totalItemCount) {
mCurrentFirstVisibleItem = firstVisibleItem;
mCurrentVisibleItemCount = visibleItemCount;
mPreviousFirstVisibleItem = (mPreviousFirstVisibleItem == -1) ? mCurrentFirstVisibleItem
: mPreviousFirstVisibleItem;
mPreviousVisibleItemCount = (mPreviousVisibleItemCount == -1) ? mCurrentVisibleItemCount
: mPreviousVisibleItemCount;
checkAndHandleFirstVisibleCellChange();
checkAndHandleLastVisibleCellChange();
mPreviousFirstVisibleItem = mCurrentFirstVisibleItem;
mPreviousVisibleItemCount = mCurrentVisibleItemCount;
}
@Override
public void onScrollStateChanged(AbsListView view, int scrollState) {
mCurrentScrollState = scrollState;
mScrollState = scrollState;
isScrollCompleted();
}
/**
* This method is in charge of invoking 1 of 2 actions. Firstly, if the listview
* is in a state of scrolling invoked by the hover cell being outside the bounds
* of the listview, then this scrolling event is continued. Secondly, if the hover
* cell has already been released, this invokes the animation for the hover cell
* to return to its correct position after the listview has entered an idle scroll
* state.
*/
private void isScrollCompleted() {
if (mCurrentVisibleItemCount > 0 && mCurrentScrollState == SCROLL_STATE_IDLE) {
if (mCellIsMobile && mIsMobileScrolling) {
handleMobileCellScroll();
} else if (mIsWaitingForScrollFinish) {
touchEventsEnded();
}
}
}
/**
* Determines if the listview scrolled up enough to reveal a new cell at the
* top of the list. If so, then the appropriate parameters are updated.
*/
public void checkAndHandleFirstVisibleCellChange() {
if (mCurrentFirstVisibleItem != mPreviousFirstVisibleItem) {
if (mCellIsMobile && mMobileItemId != INVALID_ID) {
updateNeighborViewsForID(mMobileItemId);
handleCellSwitch();
}
}
}
/**
* Determines if the listview scrolled down enough to reveal a new cell at the
* bottom of the list. If so, then the appropriate parameters are updated.
*/
public void checkAndHandleLastVisibleCellChange() {
int currentLastVisibleItem = mCurrentFirstVisibleItem + mCurrentVisibleItemCount;
int previousLastVisibleItem = mPreviousFirstVisibleItem + mPreviousVisibleItemCount;
if (currentLastVisibleItem != previousLastVisibleItem) {
if (mCellIsMobile && mMobileItemId != INVALID_ID) {
updateNeighborViewsForID(mMobileItemId);
handleCellSwitch();
}
}
}
};
public static interface DynamicListActionListener{
public void swapItems(int from, int to);
public void removeItem(int which);
}
}

73
app/src/main/java/com/ericsson/uecontrol/gui/util/StableArrayAdapter.java Executable file
View file

@ -0,0 +1,73 @@
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.ericsson.uecontrol.gui.util;
import android.content.Context;
import android.widget.ArrayAdapter;
import java.util.HashMap;
import java.util.List;
public class StableArrayAdapter<T> extends ArrayAdapter<T> implements DynamicListView.DynamicListActionListener {
final int INVALID_ID = -1;
private HashMap<T, Integer> mIdMap = new HashMap<T, Integer>();
private List<T> objects;
public StableArrayAdapter(Context context, int textViewResourceId, List<T> obj) {
super(context, textViewResourceId, obj);
objects = obj;
generateIds();
}
public void generateIds(){
mIdMap.clear();
for (int i = 0; i < objects.size(); ++i) {
mIdMap.put(objects.get(i), i);
}
}
@Override
public long getItemId(int position) {
if (position < 0 || position >= mIdMap.size()) {
return INVALID_ID;
}
T item = getItem(position);
return mIdMap.get(item);
}
@Override
public void swapItems(int from, int to) {
T temp = objects.get(from);
objects.set(from, objects.get(to));
objects.set(to, temp);
}
@Override
public void removeItem(int which) {
objects.remove(which);
generateIds();
}
@Override
public boolean hasStableIds() {
return true;
}
}