Add incomplete ConcurrentNotesWidgetSizeCalculator

- should be used by ConcurrentNotesWidget to help measure and lay itself out

Author: ataulm

mobile/src/main/java/com/ataulm/notes/ConcurrentNotesWidgetSizeCalculator.java

@@ -0,0 +1,57 @@
+package com.ataulm.notes;
+
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+/*
+ * This class depends on knowing what the layout looks like. Makes sense if it handles size and position of different notes.
+ */
+class ConcurrentNotesWidgetSizeCalculator {
+
+    private static final Comparator<Note> NOTE_COMPARATOR = new Comparator<Note>() {
+        @Override
+        public int compare(Note o1, Note o2) {
+            if (o1.midi() == o2.midi()) {
+                return 0;
+            }
+            if (o1.midi() > o2.midi()) {
+                return 1;
+            } else {
+                return -1;
+            }
+        }
+    };
+
+    private final MusicalSymbolSizes symbolSizes;
+    private final PositionsApartFromMiddleCCalculator positionCalculator;
+
+    ConcurrentNotesWidgetSizeCalculator(MusicalSymbolSizes symbolSizes, PositionsApartFromMiddleCCalculator positionCalculator) {
+        this.symbolSizes = symbolSizes;
+        this.positionCalculator = positionCalculator;
+    }
+
+    Size size(Key key, ConcurrentNotes concurrentNotes) {
+        List<Note> notes = new ArrayList<>(concurrentNotes.notes());
+        Collections.sort(notes, NOTE_COMPARATOR);
+
+        return Size.create(requiredWidth(notes), requiredHeight(key, notes));
+    }
+
+    private int requiredWidth(List<Note> notes) {
+        // TODO: best case is symbolSizes.note.width()
+        // also need to account for:
+        // accidentals,
+        // notes which are too close to each other to be displayed directly beneath each other,
+        // and accidentals which are too close to each other to be displayed directly beneath each other
+        return symbolSizes.note.width();
+    }
+
+    private int requiredHeight(Key key, List<Note> notes) {
+        // TODO: need to account for accidentals
+        return symbolSizes.note.height();
+    }
+
+}

mobile/src/test/java/com/ataulm/notes/ConcurrentNotesWidgetSizeCalculatorTest.java

@@ -0,0 +1,55 @@
+package com.ataulm.notes;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+import static com.ataulm.notes.Fixtures.C4;
+import static org.fest.assertions.api.Assertions.assertThat;
+
+public class ConcurrentNotesWidgetSizeCalculatorTest {
+
+    private static final int NOTE_WIDTH = 10;
+    private static final int NOTE_HEIGHT = 10;
+
+    private static final int SHARP_WIDTH = 10;
+    private static final int SHARP_HEIGHT = 10;
+
+    private static final int FLAT_WIDTH = 10;
+    private static final int FLAT_HEIGHT = 10;
+
+    private static final int NATURAL_WIDTH = 10;
+    private static final int NATURAL_HEIGHT = 10;
+
+    @Rule
+    public MockitoRule rule = MockitoJUnit.rule();
+
+    @Mock
+    PositionsApartFromMiddleCCalculator positionCalculator;
+
+    ConcurrentNotesWidgetSizeCalculator calculator;
+
+    @Before
+    public void setUp() {
+        MusicalSymbolSizes symbolSizes = new MusicalSymbolSizes(
+                Size.create(NOTE_WIDTH, NOTE_HEIGHT),
+                Size.create(SHARP_WIDTH, SHARP_HEIGHT),
+                Size.create(FLAT_WIDTH, FLAT_HEIGHT),
+                Size.create(NATURAL_WIDTH, NATURAL_HEIGHT)
+        );
+        calculator = new ConcurrentNotesWidgetSizeCalculator(symbolSizes, positionCalculator);
+    }
+
+    @Test
+    public void whenSizingSingleNote_thenSizeMatchesSingleNote() {
+        ConcurrentNotes notes = ConcurrentNotes.create(C4);
+
+        Size size = calculator.size(Key.C_MAJ, notes);
+
+        assertThat(size).isEqualTo(Size.create(NOTE_WIDTH, NOTE_HEIGHT));
+    }
+
+}