-
Notifications
You must be signed in to change notification settings - Fork 2
Daily stand up summaries
Considering iPhone app finished for sprint 1, we will not risk breaking the app on the device again after the bug we had on friday. We have a memory leak problem in the Android app, where the ref count grows seemingly without bounds as we refresh the list models. Using events to update the top banner when we change widgets makes the problem even bigger. We also have an issue with color settings that does not work properly on 2.1. Today we will be focusing on the Android app, make small adjustments to make it ready for sprint 1.
All four iPhone widgets are now looking nice, and their main UIs are in a shippable state. Today we're moving on to implementing widget configuration and global configuration. We've decided on a UI for this, and will start with implementing that. In order to store these settings to the key-value store, we probably want to have a unified interface (IPersistenceService) to access it on both platforms. However, todays code will be iPhone specific so it's not strictly needed yet so the platform agnostic KV store won't be a priority today (we'll skip implementing it for now unless it makes us complete the settings faster).
On Android we've fixed the animation issue, so flicking between widgets now shows a smooth transition. We also had time to work on general improvements in code quality. There's one last bug that needs to be ironed out for the animation, where the wrong widget is displayed in the very first frame of the animation. The first priority on Android is to squash that bug, then we'll move on to new tasks (picking from the next sprint).
Great work! The iPhone app is in a great state. It looks even better on the device, which I will show you later today. Might be a good idea to skip a general/common framework for persistence due to the fact that we are so low on time (only a few hours before the end of the sprint). But we will need this if we expand to the Windows 7 Phone platform - and maybe even add more advanced config on the Android app. Anyway - awesome work. Looking forward to seeing the results at the end of the day. -Alex.
Yesterday we worked on flipping between widgets with a flick gesture. This is now possible, but we still have issues with the animation, which we will continue with today. On the iPhone we worked on the Latest Commits widget, and will continue today with styling this and perhaps other widgets. We're looking into how to best define global app-specific styles on the iPhone. Possibly we'll also get a version of Working days left up and running today.
We've discussed a remake of the IModelService interface. We had the following signatures:
IEnumerable<T> Get(IDictionary<string, string> args);
T GetSingle(IDictionary<string, string> args);
We'll remove this and exchange it with the following:
T Get();
T Get(IDictionary<string, string> args);
The methods no longer return an IEnumerable, and instead return a single object, that may or may not wrap an enumerable of model objects. This is motivated by several reasons. For instance The WorkingDaysLeft widget doesn't need an IEnumerable of anything. At the same time, TopCommitters needs extra metadata about the request, so it previously had to wrap a list of Committers inside a TopCommitters that was returned inside an IEnumerable. With the rewrite we'll avoid this.
On the Android side we've focused on clean up and fixes. We begun extracting colors and strings out of each view, in order to get a consistent look and feel. Extracting strings cleans up the code (and can allow us to do internationalization in the future). One important problem was that our service locator was taken away from us at runtime by Android (to clear up memory). This was fixed, and now we know that we can't in general share resources between Activities, and if we need to keep global state, it needs to be in SmeedeeApplication.
On the iPhone, we've got a simple version of the Latest Commits widget up and running. The only widget then that doesn't exist on the iPhone is the WorkingDaysLeft widget, which should be a quick job. The biggest issue with the Latest Commits widget was to fit commit messages of varying length and constant font size into the view, as this requires manual resizing of the UI components. This is now done, so what remains for this sprint is mainly to make the various widgets look better.
Last Friday we completed all the Android specific goals for this sprint, and most of us started working on the preference screens and UI polishing. For the preference screens, it turns out the built-in PreferenceScreen object is able to build these for us very easily. However, some work still needs to be done in the cases where we want to extend the standard UI-components, for instance when coloring the text in a color selection screen. All in all though, preference screens seem to be something we can complete faster than expected.
Today we will continue to work on preferences and UI polish, hooking the preferences up to the PersistenceService (to store and retrieve the settings). We've also started work on a scheme for refreshing data: Each widget will implement a specific refresh method, and a field expressing how often the widget wants to be refreshed. This also allows us to give the user a way to manually refresh each widget, while the UI and logic for this handled by the framework, not the widget.
Also: The mac has arrived!
Yesterday the TopCommitters model was redone according to our new policy of "the service does the logic of fetching and converting to domain model", and the UI will get some finishing touches today. Global settings have been largely implemented, and can now be used to change server/password token as well as viewing all available widgets. Today implementation of the checkboxes that selects enabled widgets will be worked on. Yesterday some work on the top banner was done, but after a small meeting after the stand up we decided on a look we wanted and will implement that today or later. Latest commits widget was pretty much done yesterday and now shows a nice red "missing comment" when required, and has beautified "x numbers ago" timestamping.
Architecture wise we decided that we want the models to adhere to SRP and not do any loading from external sources. Thus the models will only contain data and perform logic that is directly related to those data. Our integration services have been interfaced to return either an IEnumerable or a single IModel instance.
Yesterday we finished the login UI complete with validation of input fields. The latest commits widget and top commiters widget UI was started and the model for working days left was finished. Global settings are pretty much done and is now showing all widgets available and information based on the widget class attributes.
A general widget attribute model was created that is used to represent static widget information such as name and icon. Also a "bootstrapper"/main activity was created that decide where to take us next based on whether we have filled in server information, have configured widgets etc.
Things are coming together nicely!
Yesterday a global menu with two sub menus were created. A working day left widget has also been made which now looks fairly good, and some work has been done on the model. Today this might be completed, and work on its settings-view or another widget can be started. We also created a simple IoC container to store dependencies in a central place. Today we'll get started on the build status widget, the login screen and perhaps a global theme that will style all buttons and other ui components in Smeedee.
Great work! I like the fact that we are starting the widgets early. Keep it up! -Alex.
We now have an API for data storage and a serializer that will be able to store any object as a json string (later on that day we discovered that the json serialization could not be done on mobile devices and needs to be fixed). We also have a working slideshow where we can put widgets and switch between them based on time or using buttons.
The JSON serializer/storage work was still valuable: we have learned many lessons from it. We also "failed fast" here and didn't lose much time (I have lost weeks of work in other projects where I didn't fail fast enough). Sounds like a great start to some important parts of the UI were done today too. -Alex.
Friday was spent doing sprint planning and getting dynamic widget loading using reflection. Smeedee is up and running in the office and today we'll break the user stories into smaller tasks and start coding.
Great! It is important to build up the backlog at this early stage of the project, and have Smeedee desktop up and running on a big screen - so we can be reminded of what it is we are actually working for. -Alex.
Today we finished off some mockups of the widgets and the UI. Me and Dag Olav also ironed out some issues involving sharing projects between Visual Studio and MonoDevelop. In the afternoon we worked on dynamically loading widgets by scanning through the compiled assemblies.
This week, people have been learning the technologies such as git, Mono for Android, and Async programming with C#. Some RSS Reader apps were built by the students (in groups of two) to "warm them up". Today they were demo'd to each other. In the afternoon we are creating the backlog, and planning Sprint 1.