diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Intervals.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Intervals.java new file mode 100644 index 00000000..b5402cd5 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Intervals.java @@ -0,0 +1,19 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Interval; +import java.util.ArrayList; + +public class Intervals { + private ArrayList intervals;; + + public Intervals(){ + this.intervals = new ArrayList<>(); + } + public void addInterval(Interval interval){ + intervals.add(interval); + } + public ArrayList getIntervalArrayList(){ + return intervals; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Fragment.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Fragment.java index 55cfdbef..ae6cae77 100644 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Fragment.java +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Fragment.java @@ -83,7 +83,7 @@ public class Iperf3Fragment extends Fragment { private final String IPERF3CPORT = "iperf3cport"; private CheckBox iperf3BiDir; private CheckBox iperf3Reverse; - private CheckBox iperf3Json; + private CheckBox iperf3OneOff; private EditText iperf3EtIp; private EditText iperf3EtPort; @@ -169,7 +169,6 @@ public void onChanged(String s) { iperf3Reverse.setChecked(iperf3RunResult.input.iperf3Reverse); iperf3BiDir.setChecked(iperf3RunResult.input.iperf3BiDir); - iperf3Json.setChecked(iperf3RunResult.input.iperf3Json); iperf3OneOff.setChecked(iperf3RunResult.input.iperf3OneOff); protocolSpinner.setSelection(iperf3RunResult.input.iperf3IdxProtocol); iperf3ModeSpinner.setSelection(iperf3RunResult.input.iperf3IdxMode); @@ -304,12 +303,10 @@ public void afterTextChanged(Editable s) { iperf3BiDir = v.findViewById(R.id.iperf_bidir); iperf3Reverse = v.findViewById(R.id.iperf3_reverse); - iperf3Json = v.findViewById(R.id.iperf3_json); iperf3OneOff = v.findViewById(R.id.iperf3_one_off); saveCheckboxInputToSharedPreferences(iperf3BiDir, IPERF3BIDIR); saveCheckboxInputToSharedPreferences(iperf3Reverse, IPERF3REVERSE); - saveCheckboxInputToSharedPreferences(iperf3Json, IPERF3JSON); saveCheckboxInputToSharedPreferences(iperf3OneOff, IPERF3ONEOFF); protocolSpinner = v.findViewById(R.id.iperf3_protocol_spinner); @@ -352,7 +349,6 @@ public void onFragmentResult(@NonNull String requestKey, iperf3Reverse.setChecked(iperf3RunResult.input.iperf3Reverse); iperf3BiDir.setChecked(iperf3RunResult.input.iperf3BiDir); - iperf3Json.setChecked(iperf3RunResult.input.iperf3Json); iperf3OneOff.setChecked(iperf3RunResult.input.iperf3OneOff); protocolSpinner.setSelection(iperf3RunResult.input.iperf3IdxProtocol); iperf3ModeSpinner.setSelection(iperf3RunResult.input.iperf3IdxMode); @@ -375,7 +371,6 @@ public void onFragmentResult(@NonNull String requestKey, iperf3BiDir.setChecked(savedInstanceState.getBoolean(IPERF3BIDIR)); iperf3Reverse.setChecked(savedInstanceState.getBoolean(IPERF3REVERSE)); - iperf3Json.setChecked(savedInstanceState.getBoolean(IPERF3JSON)); iperf3OneOff.setChecked(savedInstanceState.getBoolean(IPERF3ONEOFF)); protocolSpinner.setSelection(savedInstanceState.getInt(IPERF3IDXPROTOCOL)); iperf3ModeSpinner.setSelection(savedInstanceState.getInt(IPERF3IDXMODE)); @@ -391,7 +386,6 @@ public void onFragmentResult(@NonNull String requestKey, iperf3BiDir.setChecked(preferences.getBoolean(IPERF3BIDIR, false)); iperf3Reverse.setChecked(preferences.getBoolean(IPERF3REVERSE, false)); - iperf3Json.setChecked(preferences.getBoolean(IPERF3JSON, false)); iperf3OneOff.setChecked(preferences.getBoolean(IPERF3ONEOFF, false)); protocolSpinner.setSelection(preferences.getInt(IPERF3IDXPROTOCOL, 0)); iperf3ModeSpinner.setSelection(preferences.getInt(IPERF3IDXMODE, 0)); @@ -630,7 +624,7 @@ private String parseInput() { input.iperf3BiDir = false; input.iperf3Reverse = false; input.iperf3OneOff = false; - input.iperf3Json = false; + input.iperf3Json = true; if (!isModeSpinnerClient()) { stb.add("-s"); @@ -648,10 +642,8 @@ private String parseInput() { stb.add("--one-off"); input.iperf3OneOff = true; } - if (iperf3Json.isChecked()) { - stb.add("--json"); - input.iperf3Json = true; - } + stb.add("--json-stream"); + String joined = String.join(" ", stb); @@ -682,7 +674,6 @@ private void writeToSP() { editor.putBoolean(IPERF3BIDIR, iperf3BiDir.isChecked()); editor.putBoolean(IPERF3REVERSE, iperf3Reverse.isChecked()); - editor.putBoolean(IPERF3JSON, iperf3Json.isChecked()); editor.putBoolean(IPERF3ONEOFF, iperf3OneOff.isChecked()); editor.apply(); } diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3LogFragment.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3LogFragment.java index 2dc8b13e..74d40e8a 100644 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3LogFragment.java +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3LogFragment.java @@ -9,7 +9,9 @@ package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3; import android.content.Context; +import android.graphics.Typeface; import android.graphics.drawable.Drawable; +import android.graphics.drawable.GradientDrawable; import android.os.Bundle; import android.os.Handler; import android.os.Looper; @@ -29,13 +31,24 @@ import androidx.core.widget.TextViewCompat; import androidx.fragment.app.Fragment; +import com.github.anastr.speedviewlib.SpeedView; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Error; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Interval; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.Sum; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP.TCP_UL_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP.UDP_DL_SUM; +import java.beans.PropertyChangeEvent; +import java.beans.PropertyChangeListener; import java.io.BufferedReader; import java.io.File; import java.io.FileNotFoundException; import java.io.FileReader; -import java.io.IOException; import de.fraunhofer.fokus.OpenMobileNetworkToolkit.R; +import java.util.ArrayList; +import java.util.Locale; +import java.util.function.Function; public class Iperf3LogFragment extends Fragment { @@ -51,10 +64,227 @@ public class Iperf3LogFragment extends Fragment { private ImageView uploadIconView; private TextView iperf3OutputViewer; + private SpeedView speedView; private LinearLayout parameterLL; private Context ct; + private LinearLayout metricLL; + private Metric defaultReverseThroughput; + private Metric defaultThroughput; + private Metric defaultRTT; + private Metric defaultJITTER; + private Metric PACKET_LOSS; + public class Metric { + private LinearLayout mean; + private LinearLayout median; + private LinearLayout max; + private LinearLayout min; + private LinearLayout last; + private TextView directionName; + private ArrayList meanList = new ArrayList<>(); + private double maxValueSum = Double.MIN_VALUE; + private double minValueSum = Double.MAX_VALUE; + private METRIC_TYPE metricType; + public Metric(METRIC_TYPE metricType){ + this.metricType = metricType; + } + + private LinearLayout createTile(String key) { + LinearLayout ll = new LinearLayout(ct); + + GradientDrawable gd = new GradientDrawable(); + gd.setColor(ct.getColor(R.color.cardview_dark_background)); + gd.setCornerRadius(10); + gd.setStroke(2, 0xFF000000); + ll.setBackground(gd); + ll.setMinimumHeight(ll.getWidth()); + ll.setGravity(Gravity.CENTER); + + ll.setOrientation(LinearLayout.VERTICAL); + LinearLayout.LayoutParams foo = new LinearLayout.LayoutParams(200, 150); + foo.weight = 1; + foo.setMargins(10, 10, 10, 10); + ll.setLayoutParams(foo); + TextView keyView = new TextView(ct); + keyView.setGravity(Gravity.CENTER); + LinearLayout.LayoutParams keyViewLayoutParams = new LinearLayout.LayoutParams(200, 50); + keyViewLayoutParams.setMargins(0, 0, 0, 10); + keyView.setLayoutParams(keyViewLayoutParams); + keyView.setTypeface(null, Typeface.BOLD); + + keyView.setText(key); + ll.addView(keyView); + TextView valueView = new TextView(ct); + valueView.setGravity(Gravity.CENTER); + LinearLayout.LayoutParams valueViewLayoutParams = new LinearLayout.LayoutParams(200, 50); + valueViewLayoutParams.setMargins(0, 0, 0, 0); + valueView.setLayoutParams(valueViewLayoutParams); + ll.addView(valueView); + return ll; + } + + private LinearLayout createLL(String key) { + LinearLayout ll = null; + switch (key) { + case "mean": + mean = createTile(key); + ll = mean; + break; + case "median": + median = createTile(key); + ll = median; + break; + case "max": + max = createTile(key); + ll = max; + break; + case "min": + min = createTile(key); + ll = min; + break; + case "last": + last = createTile(key); + ll = last; + break; + } + return ll; + } + private String getFormatedString(double value){ + switch (this.metricType){ + case THROUGHPUT: + return String.format(Locale.getDefault(), "%.2f", value/1e+6); + case RTT: + case PACKET_LOSS: + case JITTER: + return String.format(Locale.getDefault(), "%.2f", value); + } + return Double.toString(value); + } + private LinearLayout createOneDirection(String direction) { + LinearLayout oneDirection = new LinearLayout(ct); + LinearLayout.LayoutParams foo1 = new LinearLayout.LayoutParams( + LinearLayout.LayoutParams.MATCH_PARENT, + LinearLayout.LayoutParams.WRAP_CONTENT + ); + oneDirection.setOrientation(LinearLayout.VERTICAL); + oneDirection.setLayoutParams(foo1); + + directionName = new TextView(ct); + directionName.setText(direction); + oneDirection.addView(directionName); + + LinearLayout cardViewResult = new LinearLayout(ct); + LinearLayout.LayoutParams cardParams = new LinearLayout.LayoutParams( + LinearLayout.LayoutParams.MATCH_PARENT, + LinearLayout.LayoutParams.WRAP_CONTENT + ); + cardViewResult.setOrientation(LinearLayout.HORIZONTAL); + cardViewResult.setLayoutParams(cardParams); + + cardViewResult.addView(createLL("mean")); + cardViewResult.addView(createLL("median")); + cardViewResult.addView(createLL("max")); + cardViewResult.addView(createLL("min")); + cardViewResult.addView(createLL("last")); + oneDirection.addView(cardViewResult); + return oneDirection; + } + + public double calcMean(){ + return meanList.stream().mapToDouble(a -> a).sum()/meanList.size(); + } + + public double calcMedian(){ + this.getMeanList().sort(Double::compareTo); + return meanList.get(Math.round(meanList.size()/2)); + } + + public double calcMax(){ + return meanList.stream().mapToDouble(a -> a).max().getAsDouble(); + } + + public double calcMin(){ + return meanList.stream().mapToDouble(a -> a).min().getAsDouble(); + } + public void update(Double value){ + this.meanList.add(value); + + ((TextView)mean.getChildAt(1)).setText(String.format(" %s", getFormatedString(calcMean()))); + ((TextView)median.getChildAt(1)).setText(String.format(" %s", getFormatedString(calcMedian()))); + ((TextView)max.getChildAt(1)).setText(String.format(" %s", getFormatedString(calcMax()))); + ((TextView)min.getChildAt(1)).setText(String.format(" %s", getFormatedString(calcMin()))); + ((TextView)last.getChildAt(1)).setText(String.format(" %s", getFormatedString(meanList.get(meanList.size()-1)))); + } + + public ArrayList getMeanList() { + return meanList; + } + public void setMaxValueSum(double maxValueSum) { + this.maxValueSum = maxValueSum; + } + public void setMinValueSum(double minValueSum) { + this.minValueSum = minValueSum; + } + public double getMaxValueSum() { + return maxValueSum; + } + public double getMinValueSum() { + return minValueSum; + } + + public void setMeanList(ArrayList meanList) { + this.meanList = meanList; + } + + public LinearLayout getMean() { + return mean; + } + + public void setMean(LinearLayout mean) { + this.mean = mean; + } + + public LinearLayout getMedian() { + return median; + } + + public void setMedian(LinearLayout median) { + this.median = median; + } + + public LinearLayout getMax() { + return max; + } + + public void setMax(LinearLayout max) { + this.max = max; + } + + public LinearLayout getMin() { + return min; + } + + public void setMin(LinearLayout min) { + this.min = min; + } + + public LinearLayout getLast() { + return last; + } + + public void setLast(LinearLayout last) { + this.last = last; + } + + public TextView getDirectionName() { + return directionName; + } + + public void setDirectionName(TextView directionName) { + this.directionName = directionName; + } + } + public Iperf3LogFragment() { - // Required empty public constructor } @@ -76,6 +306,7 @@ public void run() { runIconView.setImageDrawable(runIcon); uploadIcon = Iperf3Utils.getDrawableUpload(ct, iperf3RunResult.result, iperf3RunResult.uploaded); uploadIconView.setImageDrawable(uploadIcon); + BufferedReader br = null; StringBuilder text = new StringBuilder(); @@ -87,34 +318,71 @@ public void run() { return; } String line; - try { - while ((line = br.readLine()) != null) { - text.append(line); - text.append('\n'); - } - br.close(); - iperf3OutputViewer.setText(text.toString()); - } catch (IOException e) { - logHandler.removeCallbacks(logUpdate); - Log.d(TAG, "onCreateView: failed"); - return; - } + Iperf3Parser iperf3Parser = new Iperf3Parser(iperf3RunResult.input.iperf3rawIperf3file); + iperf3Parser.addPropertyChangeListener(new PropertyChangeListener() { + + private void parseSum(Sum sum, Metric throughput){ + SUM_TYPE sumType = sum.getSumType(); + throughput.update(sum.getBits_per_second()); + switch (sumType){ + case UDP_DL: + defaultJITTER.update(((UDP_DL_SUM)sum).getJitter_ms()); + PACKET_LOSS.update((double) ((UDP_DL_SUM) sum).getLost_percent()); + case TCP_DL: + if(throughput.directionName.getText().equals("Throughput")){ + throughput.directionName.setText("Downlink Mbit/s"); + } + break; + case UDP_UL: + case TCP_UL: + if(throughput.directionName.getText().equals("Throughput")){ + throughput.directionName.setText("Uplink Mbit/s"); + } + break; + } + } + public void propertyChange(PropertyChangeEvent evt) { + + switch (evt.getPropertyName()){ + case "interval": + Interval interval = (Interval) evt.getNewValue(); + parseSum(interval.getSum(), defaultThroughput); + if(interval.getSumBidirReverse() != null) parseSum(interval.getSumBidirReverse(), + defaultReverseThroughput); + break; + case "start": + break; + case "end": + break; + case "error": + Error error = (Error) evt.getNewValue(); + TextView errorView = new TextView(ct); + errorView.setText(error.getError()); + errorView.setTextColor(ct.getColor(R.color.crimson)); + errorView.setPadding(10, 10, 10, 10); + errorView.setTextSize(20); + metricLL.addView(errorView); + break; + } + } + }); + iperf3Parser.parse(); if (iperf3RunResult.result != -100) { logHandler.removeCallbacks(logUpdate); return; } - - - setFields(iperf3RunResult); logHandler.removeCallbacks(logUpdate); logHandler.postDelayed(this, 1000); } }; + + + @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) { @@ -249,8 +517,49 @@ public void onClick(View v) { 1, 10, 1, TypedValue.COMPLEX_UNIT_SP); iperf3OutputViewer.setTextIsSelectable(true); - scrollView.addView(iperf3OutputViewer); - secondRow.addView(scrollView); + + metricLL = new LinearLayout(ct); + metricLL.setOrientation(LinearLayout.VERTICAL); + metricLL.setLayoutParams(new LinearLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.WRAP_CONTENT)); + + + + defaultThroughput = new Metric(METRIC_TYPE.THROUGHPUT); + defaultReverseThroughput = new Metric(METRIC_TYPE.THROUGHPUT); + + metricLL.addView(defaultThroughput.createOneDirection("Throughput")); + + if(iperf3RunResult.input.iperf3BiDir) { + metricLL.addView(defaultReverseThroughput.createOneDirection("Throughput")); + if(iperf3RunResult.input.iperf3IdxProtocol == 0) { + //defaultRTT = new Metric(METRIC_TYPE.RTT); + //metricLL.addView(defaultRTT.createOneDirection("RTT")); + }; + if(iperf3RunResult.input.iperf3IdxProtocol == 1) { + defaultJITTER = new Metric(METRIC_TYPE.JITTER); + metricLL.addView(defaultJITTER.createOneDirection("Jitter ms")); + PACKET_LOSS = new Metric(METRIC_TYPE.PACKET_LOSS); + metricLL.addView(PACKET_LOSS.createOneDirection("Packet Loss %")); + }; + }; + if(iperf3RunResult.input.iperf3Reverse) { + if(iperf3RunResult.input.iperf3IdxProtocol == 1) { + defaultJITTER = new Metric(METRIC_TYPE.JITTER); + metricLL.addView(defaultJITTER.createOneDirection("Jitter ms")); + PACKET_LOSS = new Metric(METRIC_TYPE.JITTER); + metricLL.addView(PACKET_LOSS.createOneDirection("Packet Loss %")); + }; + } else if(!iperf3RunResult.input.iperf3BiDir) { + if(iperf3RunResult.input.iperf3IdxProtocol == 0) { + //defaultRTT = new Metric(METRIC_TYPE.RTT); + //metricLL.addView(defaultRTT.createOneDirection("RTT ms")); + }; + } + + mainLL.addView(metricLL); + + + mainLL.addView(secondRow); if(iperf3RunResult.input.iperf3rawIperf3file == null){ diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Parser.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Parser.java new file mode 100644 index 00000000..f3499a34 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3Parser.java @@ -0,0 +1,90 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Error; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Interval; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.start.Start; +import java.beans.PropertyChangeListener; +import java.beans.PropertyChangeSupport; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.util.Observable; +import java.util.Observer; +import org.json.JSONObject; + + +public class Iperf3Parser { + + private String pathToFile; + private File file; + private BufferedReader br = null; + private PropertyChangeSupport support; + private Start start; + private Intervals intervals = new Intervals(); + Iperf3Parser(String pathToFile) { + this.pathToFile = pathToFile; + this.file = new File(this.pathToFile); + try { + br = new BufferedReader(new FileReader(file)); + } catch (FileNotFoundException ex) { + System.out.println("File not found"); + return; + } + this.support = new PropertyChangeSupport(this); + } + + public void parse(){ + String line; + try { + while ((line = br.readLine()) != null) { + JSONObject obj = new JSONObject(line); + String event = obj.getString("event"); + switch (event) { + case "start": + start = new Start(); + JSONObject startData = obj.getJSONObject("data"); + start.parseStart(startData); + break; + case "interval": + Interval interval = new Interval(); + JSONObject intervalData = obj.getJSONObject("data"); + interval.parse(intervalData); + support.firePropertyChange("interval", null, interval); + intervals.addInterval(interval); + break; + case "end": + System.out.println("End"); + break; + case "error": + Error error = new Error(); + String errorString = obj.getString("data"); + error.parse(errorString); + support.firePropertyChange("error", null, error); + break; + default: + System.out.println("Unknown event"); + break; + } + } + } catch (Exception e) { + System.out.println("Error reading file"); + } + } + + public Intervals getIntervals() { + return intervals; + } + public Start getStart() { + return start; + } + public void addPropertyChangeListener(PropertyChangeListener pcl) { + support.addPropertyChangeListener(pcl); + } + + public void removePropertyChangeListener(PropertyChangeListener pcl) { + support.removePropertyChangeListener(pcl); + } + + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3RecyclerViewAdapter.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3RecyclerViewAdapter.java index 464a39cd..dfc37e1e 100644 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3RecyclerViewAdapter.java +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3RecyclerViewAdapter.java @@ -204,6 +204,7 @@ private LinearLayout thirdRow(LinearLayout ll){ Iperf3Utils.getLayoutParams(0, ViewGroup.LayoutParams.WRAP_CONTENT, 0.1F)); return ll; } + public ViewHolder(View itemView) { super(itemView); Log.d(TAG, "ViewHolder: " + itemView); @@ -221,7 +222,6 @@ public ViewHolder(View itemView) { linearLayout.addView(firstRow(new LinearLayout(context))); linearLayout.addView(secondRow(new LinearLayout(context))); linearLayout.addView(thirdRow(new LinearLayout(context))); - itemView.setOnLongClickListener(new View.OnLongClickListener() { @Override public boolean onLongClick(View v) { diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3ToLineProtocolWorker.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3ToLineProtocolWorker.java index 7f057f57..3056c8da 100644 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3ToLineProtocolWorker.java +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/Iperf3ToLineProtocolWorker.java @@ -21,14 +21,15 @@ import androidx.work.WorkerParameters; import com.google.common.base.Splitter; -import com.google.gson.Gson; import com.influxdb.client.domain.WritePrecision; import com.influxdb.client.write.Point; -import java.io.BufferedReader; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Interval; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.Stream; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.TCP.TCP_UL_STREAM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.UDP.UDP_DL_STREAM; import java.io.FileNotFoundException; import java.io.FileOutputStream; -import java.io.FileReader; import java.io.IOException; import java.util.Collections; import java.util.HashMap; @@ -39,9 +40,6 @@ import de.fraunhofer.fokus.OpenMobileNetworkToolkit.GlobalVars; import de.fraunhofer.fokus.OpenMobileNetworkToolkit.InfluxDB2x.InfluxdbConnection; import de.fraunhofer.fokus.OpenMobileNetworkToolkit.InfluxDB2x.InfluxdbConnections; -import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval; -import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Root; -import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Stream; public class Iperf3ToLineProtocolWorker extends Worker { private static final String TAG = "Iperf3UploadWorker"; @@ -146,61 +144,80 @@ public Map getTagsMap() { public Result doWork() { setup(); Data output = new Data.Builder().putBoolean("iperf3_upload", false).build(); - BufferedReader br = null; - try { - br = new BufferedReader(new FileReader(rawIperf3file)); - } catch (FileNotFoundException | NullPointerException e) { - e.printStackTrace(); - return Result.failure(output); - } - Root iperf3AsJson = new Gson().fromJson(br, Root.class); - long timestamp = iperf3AsJson.start.timestamp.timesecs*1000; + + Iperf3Parser iperf3Parser = new Iperf3Parser(rawIperf3file); + iperf3Parser.parse(); + + + long timestamp = Integer.toUnsignedLong( iperf3Parser.getStart().getTimestamp().getTimesecs())*1000; Log.d(TAG, "doWork: "+timestamp); String role = "server"; - if(iperf3AsJson.start.connectingTo != null){ + if(iperf3Parser.getStart().getConnecting_to() != null){ role = "client"; } LinkedList points = new LinkedList(); - for (Interval interval: iperf3AsJson.intervals) { - long tmpTimestamp = timestamp + (long) (interval.sum.end * 1000); - int intervalIdx = iperf3AsJson.intervals.indexOf(interval); - for (Stream stream: interval.streams){ + for (Interval interval: iperf3Parser.getIntervals().getIntervalArrayList()) { + long tmpTimestamp = timestamp + (long) (interval.getSum().getEnd() * 1000); + int intervalIdx = iperf3Parser.getIntervals().getIntervalArrayList().indexOf(interval); + for (Stream stream: interval.getStreams().getStreamArrayList()){ Point point = new Point("Iperf3"); point.addTag("run_uid", runID); point.addTag("bidir", String.valueOf(biDir)); - point.addTag("sender", String.valueOf(stream.sender)); + point.addTag("sender", String.valueOf(stream.getSender())); point.addTag("role", role); - point.addTag("socket", String.valueOf(stream.socket)); + point.addTag("socket", String.valueOf(stream.getSocket())); point.addTag("protocol", protocol); point.addTag("interval", intervalIperf); - point.addTag("version", iperf3AsJson.start.version); + point.addTag("version", iperf3Parser.getStart().getVersion()); point.addTag("reversed", String.valueOf(rev)); point.addTag("oneOff", String.valueOf(oneOff)); - point.addTag("connectingToHost", iperf3AsJson.start.connectingTo.host); - point.addTag("connectingToPort", String.valueOf(iperf3AsJson.start.connectingTo.port)); + point.addTag("connectingToHost", iperf3Parser + .getStart() + .getConnecting_to() + .getHost()); + point.addTag("connectingToPort", String.valueOf(iperf3Parser + .getStart() + .getConnecting_to() + .getPort())); point.addTag("bandwidth", bandwidth); point.addTag("duration", duration); point.addTag("bytesToTransmit", bytes); - point.addTag("streams", String.valueOf(interval.streams.size())); - point.addTag("streamIdx", String.valueOf(interval.streams.indexOf(stream))); + point.addTag("streams", String.valueOf(interval.getStreams().size())); + point.addTag("streamIdx", String.valueOf(interval.getStreams().getStreamArrayList().indexOf(stream))); point.addTag("intervalIdx", String.valueOf(intervalIdx)); - point.addField("bits_per_second", stream.bitsPerSecond); - point.addField("seconds", stream.seconds); - point.addField("bytes", stream.bytes); - - if(stream.rtt != 0) point.addField("rtt", stream.rtt); - if(stream.rttvar != 0) point.addField("rttvar", stream.rttvar); - if(stream.jitterMs != 0) point.addField("jitter_ms", stream.jitterMs); - if(protocol.equals("UDP") && rev){ - point.addField("lost_packets", stream.lostPackets); - point.addField("lost_percent", stream.lostPercent); + point.addField("bits_per_second", stream.getBits_per_second()); + point.addField("seconds", stream.getSeconds()); + point.addField("bytes", stream.getBytes()); + + + switch (stream.getStreamType()){ + case TCP_DL: + break; + case TCP_UL: + TCP_UL_STREAM tcp_ul_stream = (TCP_UL_STREAM) stream; + point.addField("snd_cwnd", tcp_ul_stream.getSnd_cwnd()); + point.addField("retransmits", tcp_ul_stream.getRetransmits()); + point.addField("snd_wnd", tcp_ul_stream.getSnd_wnd()); + point.addField("rtt", tcp_ul_stream.getRtt()); + point.addField("rttvar", tcp_ul_stream.getRttvar()); + point.addField("pmtu", tcp_ul_stream.getPmtu()); + break; + case UDP_DL: + UDP_DL_STREAM udp_dl_stream = (UDP_DL_STREAM) stream; + point.addField("jitter_ms", udp_dl_stream.getJitter_ms()); + point.addField("lost_packets", udp_dl_stream.getLost_packets()); + point.addField("packets", udp_dl_stream.getPackets()); + point.addField("lost_percent", udp_dl_stream.getLost_percent()); + break; + case UDP_UL: + break; + case UNKNOWN: + break; } - point.addField("retransmits", stream.retransmits); - point.time(tmpTimestamp, WritePrecision.MS); points.add(point); diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Connected.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Connected.java deleted file mode 100644 index d0f22178..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Connected.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Connected { - - @SerializedName("socket") - @Expose - public int socket; - @SerializedName("local_host") - @Expose - public String localHost; - @SerializedName("local_port") - @Expose - public int localPort; - @SerializedName("remote_host") - @Expose - public String remoteHost; - @SerializedName("remote_port") - @Expose - public int remotePort; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/ConnectingTo.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/ConnectingTo.java deleted file mode 100644 index 76189230..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/ConnectingTo.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class ConnectingTo { - - @SerializedName("host") - @Expose - public String host; - @SerializedName("port") - @Expose - public int port; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/CpuUtilizationPercent.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/CpuUtilizationPercent.java deleted file mode 100644 index 4c100394..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/CpuUtilizationPercent.java +++ /dev/null @@ -1,35 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class CpuUtilizationPercent { - - @SerializedName("host_total") - @Expose - public float hostTotal; - @SerializedName("host_user") - @Expose - public float hostUser; - @SerializedName("host_system") - @Expose - public float hostSystem; - @SerializedName("remote_total") - @Expose - public float remoteTotal; - @SerializedName("remote_user") - @Expose - public float remoteUser; - @SerializedName("remote_system") - @Expose - public float remoteSystem; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/End.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/End.java deleted file mode 100644 index 1f6bd544..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/End.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -import java.util.List; - -public class End { - - @SerializedName("streams") - @Expose - public List streams; - @SerializedName("sum") - @Expose - public Sum sum; - @SerializedName("sum_sent") - @Expose - public SumSent sumSent; - @SerializedName("sum_received") - @Expose - public SumReceived sumReceived; - @SerializedName("cpu_utilization_percent") - @Expose - public CpuUtilizationPercent cpuUtilizationPercent; - @SerializedName("sender_tcp_congestion") - @Expose - public String senderTcpCongestion; - @SerializedName("receiver_tcp_congestion") - @Expose - public String receiverTcpCongestion; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Error.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Error.java new file mode 100644 index 00000000..e1444cab --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Error.java @@ -0,0 +1,28 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; + +import org.json.JSONException; +import org.json.JSONObject; + +public class Error { + private String error; + + public Error() { + } + + public String getError() { + return error; + } + + public void setError(String error) { + this.error = error; + } + + public void parse(String data) throws JSONException { + this.error = data; + } + + public String toString() { + return "Error: " + error; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval.java deleted file mode 100644 index d4ed5933..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval.java +++ /dev/null @@ -1,25 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -import java.util.List; - -public class Interval { - - @SerializedName("streams") - @Expose - public List streams = null; - @SerializedName("sum") - @Expose - public Sum sum; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Interval.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Interval.java new file mode 100644 index 00000000..4d1caf6b --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Interval.java @@ -0,0 +1,79 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval; + +import static de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE.*; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.STREAM_TYPE; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.Sum; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.Streams; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP.TCP_BIDIR_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP.TCP_DL_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP.TCP_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP.TCP_UL_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP.UDP_BIDIR_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP.UDP_DL_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP.UDP_SUM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP.UDP_UL_SUM; +import org.json.JSONException; +import org.json.JSONObject; + +public class Interval { + private Streams streams; + private Sum sum; + public Sum sumBidirReverse; + + public Interval(){ + streams = new Streams(); + } + + private SUM_TYPE getSumType(JSONObject data) throws JSONException { + boolean sender = data.getBoolean("sender"); + if(sender){ + if(data.has("retransmits")) return SUM_TYPE.TCP_UL; + if(data.has("packets")) return SUM_TYPE.UDP_UL; + } + if(data.has("jitter_ms")) return SUM_TYPE.UDP_DL; + return SUM_TYPE.TCP_DL; + } + + public Sum identifySum(JSONObject data) throws JSONException { + Sum identifiedSum = null; + switch (getSumType(data)){ + case TCP_DL: + identifiedSum = new TCP_DL_SUM(); + ((TCP_DL_SUM) identifiedSum).parse(data); + break; + case TCP_UL: + identifiedSum = new TCP_UL_SUM(); + ((TCP_UL_SUM) identifiedSum).parse(data); + break; + case UDP_DL: + identifiedSum = new UDP_DL_SUM(); + ((UDP_DL_SUM) identifiedSum).parse(data); + break; + case UDP_UL: + identifiedSum = new UDP_UL_SUM(); + ((UDP_UL_SUM) identifiedSum).parse(data); + break; + } + return identifiedSum; + } + + public void parse(JSONObject data) throws JSONException { + streams.parse(data.getJSONArray("streams")); + sum = identifySum(data.getJSONObject("sum")); + if(data.has("sum_bidir_reverse")){ + sumBidirReverse = identifySum(data.getJSONObject("sum_bidir_reverse")); + } + } + + public Streams getStreams() { + return streams; + } + public Sum getSum() { + return sum; + } + public Sum getSumBidirReverse() { + return sumBidirReverse; + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/STREAM_TYPE.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/STREAM_TYPE.java new file mode 100644 index 00000000..f5a50a29 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/STREAM_TYPE.java @@ -0,0 +1,9 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams; + +public enum STREAM_TYPE { + TCP_UL, + TCP_DL, + UDP_UL, + UDP_DL, + UNKNOWN +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/Stream.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/Stream.java new file mode 100644 index 00000000..9ec8dba1 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/Stream.java @@ -0,0 +1,64 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams; + +import org.json.JSONException; +import org.json.JSONObject; + +public class Stream { + private int socket; + private int start; + private double end; + private double seconds; + private long bytes; + private double bits_per_second; + private boolean omitted; + private boolean sender; + + private STREAM_TYPE streamType; + + public Stream(){ + } + public void parse(JSONObject data) throws JSONException { + this.socket = data.getInt("socket"); + this.start = data.getInt("start"); + this.end = data.getDouble("end"); + this.seconds = data.getDouble("seconds"); + this.bytes = data.getLong("bytes"); + this.bits_per_second = data.getDouble("bits_per_second"); + this.omitted = data.getBoolean("omitted"); + this.sender = data.getBoolean("sender"); + } + + public int getSocket() { + return socket; + } + public int getStart() { + return start; + } + public double getEnd() { + return end; + } + public double getSeconds() { + return seconds; + } + public long getBytes() { + return bytes; + } + public double getBits_per_second() { + return bits_per_second; + } + public boolean getOmitted() { + return omitted; + } + public boolean getSender() { + return sender; + } + + public STREAM_TYPE getStreamType() { + return streamType; + } + + public void setStreamType( + STREAM_TYPE streamType) { + this.streamType = streamType; + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/Streams.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/Streams.java new file mode 100644 index 00000000..b00cbc4c --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/Streams.java @@ -0,0 +1,74 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.TCP.TCP_DL_STREAM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.TCP.TCP_UL_STREAM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.UDP.UDP_DL_STREAM; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.UDP.UDP_UL_STREAM; +import java.util.ArrayList; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +public class Streams { + private ArrayList streams; + public Streams(){ + this.streams = new ArrayList<>(); + } + + private STREAM_TYPE identifyStream(JSONObject data) throws JSONException { + boolean sender = data.getBoolean("sender"); + if(sender){ + if(data.has("retransmits")) return STREAM_TYPE.TCP_UL; + if(data.has("packets")) return STREAM_TYPE.UDP_UL; + } + if(data.has("jitter_ms")) return STREAM_TYPE.UDP_DL; + return STREAM_TYPE.TCP_DL; + } + + private Stream parseStream(JSONObject data) throws JSONException{ + STREAM_TYPE type = identifyStream(data); + Stream stream = null; + switch (type) { + case TCP_UL: + stream = new TCP_UL_STREAM(); + break; + case TCP_DL: + stream = new TCP_DL_STREAM(); + break; + case UDP_UL: + stream = new UDP_UL_STREAM(); + break; + case UDP_DL: + stream = new UDP_DL_STREAM(); + break; + case UNKNOWN: + return stream; + } + stream.parse(data); + return stream; + } + + public void parse(JSONArray streams) throws JSONException { + for (int i = 0; i < streams.length(); i++) { + JSONObject streamJSONObject = streams.getJSONObject(i); + Stream stream = parseStream(streamJSONObject); + if(stream == null){ + System.out.println("Stream is null!"); + continue; + } + addStream(stream); + } + } + public int size(){ + return streams.size(); + } + public ArrayList getStreamArrayList() { + return streams; + } + public void addStream(Stream stream){ + streams.add(stream); + } + public Stream getStream(int i) { + return streams.get(i); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_DL_STREAM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_DL_STREAM.java new file mode 100644 index 00000000..93e27705 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_DL_STREAM.java @@ -0,0 +1,16 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.STREAM_TYPE; + +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_DL_STREAM extends TCP_STREAM { + public TCP_DL_STREAM(){ + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.setStreamType(STREAM_TYPE.TCP_DL); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_STREAM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_STREAM.java new file mode 100644 index 00000000..3b3e663b --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_STREAM.java @@ -0,0 +1,14 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.Stream; +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_STREAM extends Stream { + public TCP_STREAM(){ + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_UL_STREAM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_UL_STREAM.java new file mode 100644 index 00000000..a305776d --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/TCP/TCP_UL_STREAM.java @@ -0,0 +1,53 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.STREAM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_UL_STREAM extends TCP_STREAM { + private int retransmits; + private int snd_cwnd; + private int snd_wnd; + private int rtt; + private int rttvar; + private int pmtu; + + public TCP_UL_STREAM(){ + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.retransmits = data.getInt("retransmits"); + this.snd_cwnd = data.getInt("snd_cwnd"); + this.snd_wnd = data.getInt("snd_wnd"); + this.rtt = data.getInt("rtt"); + this.rttvar = data.getInt("rttvar"); + this.pmtu = data.getInt("pmtu"); + this.setStreamType(STREAM_TYPE.TCP_UL); + } + + public int getRetransmits() { + return retransmits; + } + + public int getSnd_cwnd() { + return snd_cwnd; + } + + public int getSnd_wnd() { + return snd_wnd; + } + + public int getRtt() { + return rtt; + } + + public int getRttvar() { + return rttvar; + } + + public int getPmtu() { + return pmtu; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_DL_STREAM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_DL_STREAM.java new file mode 100644 index 00000000..c6a1f4d8 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_DL_STREAM.java @@ -0,0 +1,36 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.STREAM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class UDP_DL_STREAM extends UDP_STREAM { + private double jitter_ms; + private int lost_packets; + private int packets; + private int lost_percent; + public UDP_DL_STREAM(){ + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.jitter_ms = data.getDouble("jitter_ms"); + this.lost_packets = data.getInt("lost_packets"); + this.packets = data.getInt("packets"); + this.lost_percent = data.getInt("lost_percent"); + this.setStreamType(STREAM_TYPE.UDP_DL); + } + public double getJitter_ms() { + return jitter_ms; + } + public int getLost_packets() { + return lost_packets; + } + public int getPackets() { + return packets; + } + public int getLost_percent() { + return lost_percent; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_STREAM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_STREAM.java new file mode 100644 index 00000000..acf8e17f --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_STREAM.java @@ -0,0 +1,15 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.Stream; +import org.json.JSONException; +import org.json.JSONObject; + +public class UDP_STREAM extends Stream { + public int packets; + public UDP_STREAM(){ + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_UL_STREAM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_UL_STREAM.java new file mode 100644 index 00000000..99fdda02 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Streams/UDP/UDP_UL_STREAM.java @@ -0,0 +1,15 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Streams.STREAM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class UDP_UL_STREAM extends UDP_STREAM { + public UDP_UL_STREAM(){ + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.setStreamType(STREAM_TYPE.UDP_UL); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/SUM_TYPE.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/SUM_TYPE.java new file mode 100644 index 00000000..538bbd08 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/SUM_TYPE.java @@ -0,0 +1,11 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum; + +public enum SUM_TYPE { + TCP_UL, + TCP_DL, + TCP_BIDIR, + UDP_UL, + UDP_DL, + UDP_BIDIR, + UNKNOWN +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/Sum.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/Sum.java new file mode 100644 index 00000000..c8f56f68 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/Sum.java @@ -0,0 +1,54 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum; + +import org.json.JSONException; +import org.json.JSONObject; + +public class Sum { + private int start; + private float end; + private float seconds; + private long bytes; + private double bits_per_second; + private boolean omitted; + private boolean sender; + private SUM_TYPE sumType; + public Sum(){ + } + public void parse(JSONObject data) throws JSONException { + this.start = data.getInt("start"); + this.end = (float) data.getDouble("end"); + this.seconds = (float) data.getDouble("seconds"); + this.bytes = data.getLong("bytes"); + this.bits_per_second = data.getDouble("bits_per_second"); + this.omitted = data.getBoolean("omitted"); + this.sender = data.getBoolean("sender"); + } + public int getStart() { + return start; + } + public float getEnd() { + return end; + } + public float getSeconds() { + return seconds; + } + public long getBytes() { + return bytes; + } + public double getBits_per_second() { + return bits_per_second; + } + public boolean getOmitted() { + return omitted; + } + public boolean getSender() { + return sender; + } + public SUM_TYPE getSumType() { + return sumType; + } + public void setSumType(SUM_TYPE sumType) { + this.sumType = sumType; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_BIDIR_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_BIDIR_SUM.java new file mode 100644 index 00000000..2165f579 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_BIDIR_SUM.java @@ -0,0 +1,24 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.Sum; +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_BIDIR_SUM extends TCP_SUM{ + Sum bidirReverse; + SUM_TYPE sumType; + public TCP_BIDIR_SUM() { + super(); + this.sumType = SUM_TYPE.TCP_BIDIR; + } + public void parse(JSONObject data) throws JSONException { + super.parse(data.getJSONObject("sum")); + this.bidirReverse.parse(data.getJSONObject("sum_bidir_reverse")); + + } + + public SUM_TYPE getSumType() { + return sumType; + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_DL_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_DL_SUM.java new file mode 100644 index 00000000..d664ea55 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_DL_SUM.java @@ -0,0 +1,17 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_DL_SUM extends TCP_SUM{ + public TCP_DL_SUM() { + super(); + this.setSumType(SUM_TYPE.TCP_DL); + } + + @Override + public void parse(JSONObject data) throws JSONException { + super.parse(data); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_SUM.java new file mode 100644 index 00000000..27833aea --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_SUM.java @@ -0,0 +1,15 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.Sum; +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_SUM extends Sum { + public TCP_SUM() { + super(); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_UL_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_UL_SUM.java new file mode 100644 index 00000000..e8f84261 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/TCP/TCP_UL_SUM.java @@ -0,0 +1,18 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.TCP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class TCP_UL_SUM extends TCP_SUM{ + public int retransmits; + public TCP_UL_SUM() { + super(); + this.setSumType(SUM_TYPE.TCP_UL); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.retransmits = data.getInt("retransmits"); + + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_BIDIR_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_BIDIR_SUM.java new file mode 100644 index 00000000..284a35aa --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_BIDIR_SUM.java @@ -0,0 +1,25 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.Sum; +import org.json.JSONException; +import org.json.JSONObject; + +public class UDP_BIDIR_SUM extends UDP_SUM{ + + Sum bidirReverse; + SUM_TYPE sumType; + public UDP_BIDIR_SUM() { + super(); + sumType = SUM_TYPE.UDP_BIDIR; + } + public void parse(JSONObject data) throws JSONException { + super.parse(data.getJSONObject("sum")); + this.bidirReverse.parse(data.getJSONObject("sum_bidir_reverse")); + + } + + public SUM_TYPE getSumType() { + return sumType; + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_DL_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_DL_SUM.java new file mode 100644 index 00000000..041a39e1 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_DL_SUM.java @@ -0,0 +1,37 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class UDP_DL_SUM extends UDP_SUM{ + private double jitter_ms; + private int lost_packets; + private double lost_percent; + public UDP_DL_SUM() { + super(); + this.setSumType(SUM_TYPE.UDP_DL); + } + + @Override + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.jitter_ms = data.getDouble("jitter_ms"); + this.lost_packets = data.getInt("lost_packets"); + this.lost_percent = data.getDouble("lost_percent"); + + } + + public double getJitter_ms() { + return jitter_ms; + } + + public int getLost_packets() { + return lost_packets; + } + + public double getLost_percent() { + return lost_percent; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_SUM.java new file mode 100644 index 00000000..02a4abe0 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_SUM.java @@ -0,0 +1,6 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.Sum; + +public class UDP_SUM extends Sum { +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_UL_SUM.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_UL_SUM.java new file mode 100644 index 00000000..a73bab2c --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Interval/Sum/UDP/UDP_UL_SUM.java @@ -0,0 +1,17 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.UDP; + +import de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.Interval.Sum.SUM_TYPE; +import org.json.JSONException; +import org.json.JSONObject; + +public class UDP_UL_SUM extends UDP_SUM{ + private int packets; + public UDP_UL_SUM() { + super(); + this.setSumType(SUM_TYPE.UDP_UL); + } + public void parse(JSONObject data) throws JSONException { + super.parse(data); + this.packets = data.getInt("packets"); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Receiver.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Receiver.java deleted file mode 100644 index 87eba891..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Receiver.java +++ /dev/null @@ -1,39 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Receiver { - - @SerializedName("socket") - @Expose - public int socket; - @SerializedName("start") - @Expose - public int start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public long bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("sender") - @Expose - public boolean sender; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Root.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Root.java deleted file mode 100644 index f615b5fc..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Root.java +++ /dev/null @@ -1,28 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -import java.util.List; - -public class Root { - - @SerializedName("start") - @Expose - public Start start; - @SerializedName("intervals") - @Expose - public List intervals = null; - @SerializedName("end") - @Expose - public End end; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Sender.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Sender.java deleted file mode 100644 index 93a9d870..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Sender.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Sender { - - @SerializedName("socket") - @Expose - public int socket; - @SerializedName("start") - @Expose - public int start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public long bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("retransmits") - @Expose - public int retransmits; - @SerializedName("max_snd_cwnd") - @Expose - public int maxSndCwnd; - @SerializedName("max_snd_wnd") - @Expose - public int maxSndWnd; - @SerializedName("max_rtt") - @Expose - public int maxRtt; - @SerializedName("min_rtt") - @Expose - public int minRtt; - @SerializedName("mean_rtt") - @Expose - public int meanRtt; - @SerializedName("sender") - @Expose - public boolean sender; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Start.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Start.java deleted file mode 100644 index 1f2a29b4..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Start.java +++ /dev/null @@ -1,55 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -import java.util.List; - -public class Start { - - @SerializedName("connected") - @Expose - public List connected = null; - @SerializedName("version") - @Expose - public String version; - @SerializedName("system_info") - @Expose - public String systemInfo; - @SerializedName("timestamp") - @Expose - public Timestamp timestamp; - @SerializedName("connecting_to") - @Expose - public ConnectingTo connectingTo; - @SerializedName("cookie") - @Expose - public String cookie; - @SerializedName("tcp_mss_default") - @Expose - public int tcpMssDefault; - @SerializedName("target_bitrate") - @Expose - public int targetBitrate; - @SerializedName("sock_bufsize") - @Expose - public int sockBufsize; - @SerializedName("sndbuf_actual") - @Expose - public int sndbufActual; - @SerializedName("rcvbuf_actual") - @Expose - public int rcvbufActual; - @SerializedName("test_start") - @Expose - public TestStart testStart; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Stream.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Stream.java deleted file mode 100644 index 0ff3d252..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Stream.java +++ /dev/null @@ -1,74 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Stream { - - @SerializedName("socket") - @Expose - public int socket; - @SerializedName("start") - @Expose - public float start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public long bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("retransmits") - @Expose - public int retransmits; - @SerializedName("snd_cwnd") - @Expose - public int sndCwnd; - @SerializedName("packets") - @Expose - public int packets; - @SerializedName("jitter_ms") - @Expose - public float jitterMs; - @SerializedName("lost_packets") - @Expose - public int lostPackets; - @SerializedName("lost_percent") - @Expose - public float lostPercent; - @SerializedName("snd_wnd") - @Expose - public int sndWnd; - @SerializedName("rtt") - @Expose - public int rtt; - @SerializedName("rttvar") - @Expose - public int rttvar; - @SerializedName("pmtu") - @Expose - public int outOfOrder; - @SerializedName("out_of_order") - @Expose - public int pmtu; - @SerializedName("omitted") - @Expose - public boolean omitted; - @SerializedName("sender") - @Expose - public boolean sender; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Stream__1.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Stream__1.java deleted file mode 100644 index 7add7207..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Stream__1.java +++ /dev/null @@ -1,21 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Stream__1 { - - @SerializedName("udp") - @Expose - public Stream udp; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Sum.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Sum.java deleted file mode 100644 index 07ef6675..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Sum.java +++ /dev/null @@ -1,54 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Sum { - - @SerializedName("start") - @Expose - public float start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public double bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("retransmits") - @Expose - public int retransmits; - @SerializedName("omitted") - @Expose - public boolean omitted; - @SerializedName("sender") - @Expose - public boolean sender; - - @SerializedName("packets") - @Expose - public int packets; - @SerializedName("jitter_ms") - @Expose - public float jitterMs; - @SerializedName("lost_packets") - @Expose - public int lostPackets; - @SerializedName("lost_percent") - @Expose - public float lostPercent; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/SumReceived.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/SumReceived.java deleted file mode 100644 index e8c8372b..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/SumReceived.java +++ /dev/null @@ -1,47 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class SumReceived { - - @SerializedName("start") - @Expose - public int start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public long bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("sender") - @Expose - public boolean sender; - @SerializedName("packets") - @Expose - public int packets; - @SerializedName("jitter_ms") - @Expose - public float jitterMs; - @SerializedName("lost_packets") - @Expose - public int lostPackets; - @SerializedName("lost_percent") - @Expose - public float lostPercent; -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/SumSent.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/SumSent.java deleted file mode 100644 index a83c7641..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/SumSent.java +++ /dev/null @@ -1,50 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class SumSent { - - @SerializedName("start") - @Expose - public int start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public long bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("retransmits") - @Expose - public int retransmits; - @SerializedName("sender") - @Expose - public boolean sender; - @SerializedName("packets") - @Expose - public int packets; - @SerializedName("jitter_ms") - @Expose - public float jitterMs; - @SerializedName("lost_packets") - @Expose - public int lostPackets; - @SerializedName("lost_percent") - @Expose - public float lostPercent; -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/TestStart.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/TestStart.java deleted file mode 100644 index 99fecc99..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/TestStart.java +++ /dev/null @@ -1,48 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class TestStart { - - @SerializedName("protocol") - @Expose - public String protocol; - @SerializedName("num_streams") - @Expose - public int numStreams; - @SerializedName("blksize") - @Expose - public int blksize; - @SerializedName("omit") - @Expose - public int omit; - @SerializedName("duration") - @Expose - public int duration; - @SerializedName("bytes") - @Expose - public int bytes; - @SerializedName("blocks") - @Expose - public int blocks; - @SerializedName("reverse") - @Expose - public int reverse; - @SerializedName("tos") - @Expose - public int tos; - @SerializedName("target_bitrate") - @Expose - public int targetBitrate; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Timestamp.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Timestamp.java deleted file mode 100644 index bdebf702..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Timestamp.java +++ /dev/null @@ -1,24 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Timestamp { - - @SerializedName("time") - @Expose - public String time; - @SerializedName("timesecs") - @Expose - public long timesecs; - -} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Udp.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Udp.java deleted file mode 100644 index e2ab4a90..00000000 --- a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/Udp.java +++ /dev/null @@ -1,51 +0,0 @@ -/* - * SPDX-FileCopyrightText: 2023 Peter Hasse - * SPDX-FileCopyrightText: 2023 Johann Hackler - * SPDX-FileCopyrightText: 2023 Fraunhofer FOKUS - * - * SPDX-License-Identifier: BSD-3-Clause-Clear - */ - -package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON; - -import com.google.gson.annotations.Expose; -import com.google.gson.annotations.SerializedName; - -public class Udp { - @SerializedName("socket") - @Expose - public int socket; - @SerializedName("start") - @Expose - public int start; - @SerializedName("end") - @Expose - public float end; - @SerializedName("seconds") - @Expose - public float seconds; - @SerializedName("bytes") - @Expose - public long bytes; - @SerializedName("bits_per_second") - @Expose - public float bitsPerSecond; - @SerializedName("packets") - @Expose - public int packets; - @SerializedName("jitter_ms") - @Expose - public float jitterMs; - @SerializedName("lost_packets") - @Expose - public int lostPackets; - @SerializedName("lost_percent") - @Expose - public float lostPercent; - @SerializedName("out_of_order") - @Expose - public int outOfOrder; - @SerializedName("sender") - @Expose - public boolean sender; -} \ No newline at end of file diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Connected.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Connected.java new file mode 100644 index 00000000..33f29b15 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Connected.java @@ -0,0 +1,21 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.start; + +import org.json.JSONException; +import org.json.JSONObject; + +public class Connected { + public int socket; + public String local_host; + public int local_port; + public String remote_host; + public int remote_port; + + public void parse(JSONObject data) throws JSONException { + this.socket = data.getInt("socket"); + this.local_host = data.getString("local_host"); + this.local_port = data.getInt("local_port"); + this.remote_host = data.getString("remote_host"); + this.remote_port = data.getInt("remote_port"); + + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/ConnectingTo.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/ConnectingTo.java new file mode 100644 index 00000000..6ffdb23d --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/ConnectingTo.java @@ -0,0 +1,21 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.start; + +import org.json.JSONException; +import org.json.JSONObject; + +public class ConnectingTo{ + private String host; + private int port; + + public void parse(JSONObject data) throws JSONException { + this.host = data.getString("host"); + this.port = data.getInt("port"); + } + + public String getHost() { + return host; + } + public int getPort() { + return port; + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Start.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Start.java new file mode 100644 index 00000000..30cea994 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Start.java @@ -0,0 +1,88 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.start; + +import java.util.ArrayList; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +public class Start{ + private ArrayList connected = new ArrayList(); + private String version; + private String system_info; + private Timestamp timestamp; + private ConnectingTo connecting_to; + private String cookie; + private int tcp_mss_default; + private int target_bitrate; + private int fq_rate; + private int sock_bufsize; + private int sndbuf_actual; + private int rcvbuf_actual; + private TestStart test_start; + + public Start(){ + } + public void parseStart(JSONObject data) throws JSONException { + JSONArray connected = data.getJSONArray("connected"); + for (int i = 0; i < connected.length(); i++) { + Connected connectedObj = new Connected(); + connectedObj.parse(connected.getJSONObject(i)); + this.connected.add(connectedObj); + } + this.version = data.getString("version"); + this.system_info = data.getString("system_info"); + this.timestamp = new Timestamp(); + this.timestamp.parse(data.getJSONObject("timestamp")); + this.connecting_to = new ConnectingTo(); + this.connecting_to.parse(data.getJSONObject("connecting_to")); + this.cookie = data.getString("cookie"); + if(data.has("tcp_mss_default")) this.tcp_mss_default = data.getInt("tcp_mss_default"); + this.target_bitrate = data.getInt("target_bitrate"); + this.fq_rate = data.getInt("fq_rate"); + this.sock_bufsize = data.getInt("sock_bufsize"); + this.sndbuf_actual = data.getInt("sndbuf_actual"); + this.rcvbuf_actual = data.getInt("rcvbuf_actual"); + this.test_start = new TestStart(); + this.test_start.parse(data.getJSONObject("test_start")); + } + public ArrayList getConnected() { + return connected; + } + public String getVersion() { + return version; + } + public String getSystem_info() { + return system_info; + } + public Timestamp getTimestamp() { + return timestamp; + } + public ConnectingTo getConnecting_to() { + return connecting_to; + } + public String getCookie() { + return cookie; + } + public int getTcp_mss_default() { + return tcp_mss_default; + } + public int getTarget_bitrate() { + return target_bitrate; + } + public int getFq_rate() { + return fq_rate; + } + public int getSock_bufsize() { + return sock_bufsize; + } + public int getSndbuf_actual() { + return sndbuf_actual; + } + public int getRcvbuf_actual() { + return rcvbuf_actual; + } + public TestStart getTest_start() { + return test_start; + } + +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/TestStart.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/TestStart.java new file mode 100644 index 00000000..d6d190b9 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/TestStart.java @@ -0,0 +1,36 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.start; + +import org.json.JSONException; +import org.json.JSONObject; + +public class TestStart{ + public String protocol; + public int num_streams; + public int blksize; + public int omit; + public int duration; + public int bytes; + public int blocks; + public int reverse; + public int tos; + public int target_bitrate; + public boolean bidir; + public int fqrate; + public int interval; + + public void parse(JSONObject data) throws JSONException { + this.protocol = data.getString("protocol"); + this.num_streams = data.getInt("num_streams"); + this.blksize = data.getInt("blksize"); + this.omit = data.getInt("omit"); + this.duration = data.getInt("duration"); + this.bytes = data.getInt("bytes"); + this.blocks = data.getInt("blocks"); + this.reverse = data.getInt("reverse"); + this.tos = data.getInt("tos"); + this.target_bitrate = data.getInt("target_bitrate"); + this.bidir = 1 == data.getInt("bidir"); + this.fqrate = data.getInt("fqrate"); + this.interval = data.getInt("interval"); + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Timestamp.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Timestamp.java new file mode 100644 index 00000000..27d25598 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/JSON/start/Timestamp.java @@ -0,0 +1,20 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3.JSON.start; + +import org.json.JSONException; +import org.json.JSONObject; + +public class Timestamp{ + private String time; + private int timesecs; + + public void parse(JSONObject data) throws JSONException { + this.time = data.getString("time"); + this.timesecs = data.getInt("timesecs"); + } + public String getTime() { + return time; + } + public int getTimesecs() { + return timesecs; + } +} diff --git a/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/METRIC_TYPE.java b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/METRIC_TYPE.java new file mode 100644 index 00000000..8521c4a1 --- /dev/null +++ b/app/src/main/java/de/fraunhofer/fokus/OpenMobileNetworkToolkit/Iperf3/METRIC_TYPE.java @@ -0,0 +1,8 @@ +package de.fraunhofer.fokus.OpenMobileNetworkToolkit.Iperf3; + +public enum METRIC_TYPE { + THROUGHPUT, + RTT, + JITTER, + PACKET_LOSS + } diff --git a/app/src/main/res/layout/fragment_iperf3_input.xml b/app/src/main/res/layout/fragment_iperf3_input.xml index bd98c3c9..61fa0ff7 100644 --- a/app/src/main/res/layout/fragment_iperf3_input.xml +++ b/app/src/main/res/layout/fragment_iperf3_input.xml @@ -150,20 +150,6 @@ app:layout_constraintStart_toStartOf="@+id/guideline210" app:layout_constraintTop_toTopOf="parent" /> - - Huawei Project Mediatek IMS iPerf3 - Send! + Send -c 172.17.0.1 OpenMobileNetworkToolkit logging This app is provided by NGNI a department of Fraunhofer FOKUS. \n\nhttps://www.fokus.fraunhofer.de/go/ngni \n\nThis software is licensed under BSD 3-Clause Clear License https://spdx.org/licenses/BSD-3-Clause-Clear.html \n\nAuthors: \n\nPeter Hasse \nMohsin Nisar \nJohann Hackler diff --git a/docs/iperf3.md b/docs/iperf3.md index 6274d219..2f9a018a 100644 --- a/docs/iperf3.md +++ b/docs/iperf3.md @@ -4,4 +4,5 @@ To see how to integrate iPerf3 into your app, look at [iPerf3 Repo](https://gith ![iPerf3](images/iperf3.png) + [Home](OpenMobileNetworkToolkit.md) \ No newline at end of file