Initial commit

app/src/main/java/com/ericsson/uecontrol/gui/fragments/BehaviourListFragment.java

@@ -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);
+        }
+    }
+
+}

app/src/main/java/com/ericsson/uecontrol/gui/fragments/ConfigureBehaviourDialog.java

@@ -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();
+    }
+}

app/src/main/java/com/ericsson/uecontrol/gui/fragments/NavigationDrawerFragment.java

@@ -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);
+    }
+}

app/src/main/java/com/ericsson/uecontrol/gui/fragments/SelectBehaviourDialog.java

@@ -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);
+    }
+}

app/src/main/java/com/ericsson/uecontrol/gui/fragments/StatusFragment.java

@@ -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;
+    }
+}