-
Notifications
You must be signed in to change notification settings - Fork 2
Daily stand up summaries
Last Friday was the last day in the sprint, and was spent mostly on UI polish. On both platforms we've implemented activity indicators for the login screen. (?) On the iPhone, two widgets have gotten an inline settings view, for quick editing of certain settings. We've also worked on the CachedImageService, which will cache images loaded from the net, so we don't redownload them on every refresh.
On Android we do not currently load images, while on iPhone we load them directly from the net on every app load. The current issue with the CachedImageService is that it fails when the same cache file is accessed simultaneously (which happens frequently). We need to figure out a good way to get mutual exclusion on the cache file, without locking up the app.
Last day in this sprint, so today we need to have to shippable apps, one for Android and one for iPhone. The refresh button now appears if the widget has not been refreshed for the past 5 minutes, and the user can click the button and refresh the widget. Validation is now implemented fully, and works for all services, both on Android and iPhone. Image with cache service is being worked on for the Android version. Some widget polishing will be done on Android version today.
On iOS we now have all integration done with models and services, and pictures are now inplace on the iPhone. Also a lot of layout and design have been polished, so the iPhone app really starts getting nice.
The administration panel for mobiles in the smeedee desktop application is now finished, and we can generate user keys to distribute to the users that have the smeedee mobile application. The users then use that key to login to a smeedee server in the application. We will get the real validation service finish both on server and client side today. There is now a limit of number of commits that can be shown in the Latest Commits widget. The user can click a button "Load more" to see older commit messages, but no more than 40 commits can be loaded in total. Some cleanup here and there have been done on the Android version. Server url and user key settings in Global Settings have been changed so that the user gets feedback if the connection was either successfull or failed after new values has been passed in. A notification text (and maybe a button) is being made to notify the user if there has been a long time since the widget was refreshed. Work will continue with this feature today.
A login screen has been made on iOS, and polishing som widget design. Images (and caching of those) for different purposes will be added today, such as person images in top committers widget.
All services at the server side is now finished, and we are all ready to dump the fakservices and pass in the real services! We will go through all widgets and make sure they present a decent error message if the service is not working. We have started to work on an administration panel on the smeedee desktop application, to administer the mobile clients. What's needed there is an ability to generate keys for the mobile users.
On iOS we have made the topbanner on all widgets more stylish and added a refreshbutton (without any function yet). All settings for all widgets are now working, except the coloring of list items at Latest Commits settings, we will not prioritize this feature any high any more. Server url and user key settings are now in place, and we will reuse this work to create a login screen for the iOS today.
Integration with Build Status Service and Top Committers Service have been done and testet now, works smooth. We have configured the Smeedee Desktop Installer to include the mobile services and this has also been tested, works fine. Continuing today with the last real services for Latest Changeset and Working Days Left widget, to get real data from Smeedee, and in the end of this week remove all fake servies.
On iOS we have created nice custom section headers, and tweaked the layout of all configuration screens using a Style Extension class. The configuration screens looks okay for now, and can be tuned further in Sprint 3. Focus now is to implement the remaining functionality on iOS, and let the widgets use the real services in the end of this week.
We have decided to remove the setting where the user can show/hide username of who ran a build (Build Status Widget), because it makes little sense to have this opportunity on the mobile client. The usename is always shown. The mobile client is used on the go, and if one spots that a build is broken it's nice to have the opportunity to see who have caused this and alert the corresponding person about the issue.
Integration with the server side now works with csv data. Build Status widget recieves csv data (currently from http://folk.ntnu.no/dagolap/s/) with builds and shows'em in the Android widget. Top Committers widget has its server side implemented, but it seems like there are some problems connecting to it from the mobile client. We will continue with this integration today. Created a class ServiceConstants to be used for constants conserning url's for services and such.
On iOS we now have all settings screens for all widgets, but not all functionality is in place yet. We have also tried to make a common color and style theme for all screens at the iOS, but with no luck yet. We will continue the work today.
And Børge has come back from his holiday, ready to give it all the last three weeks!
Started working on integration now, but encountered some problems with Json libraries. They either dont work very well, or is not shared on all platforms. Started implementing very simple csv handling instead.
Lots of cleanup done in iPhone UI code, time to begin increasing functionality.
We pulled the latest version of Smeedee desktop from Stavanger and installed it on a server here. Works smooth (unlike the old laptop).
Lots of small fixes and refactoring were done yesterday. Moved code for storing and retrieving the enabled state of widgets into shared code (SmeedeeApp), which simplified both platforms, and implemented an event for IWidget to notify views on description changes, among other things. Not much left for Android, only a little tweaking on the "load more" functionality of latest commits.
The Iphone app still lacks functionality. We need a login dialog, and settings views for all the widgets. The settings part of the UI seems to have pretty bad design, that we will need to fix as well (hardcoded table cells for Url/Pass input, etc).
Most of the model code should now be finished. For today: In the latest commits widget we decided to implement a "load more" functionality, instead of loading a fixed number x. The header description causes some problems when the app starts. The container will call getdescription before the underlying model has loaded, causing inconsistencies between the list data and the description. This was previously "fixed" by adding an extra call to Refresh, but we need a more elegant solution.
The iPhone app is probably broken, we need to work on that as well.
Yesterday we found a very neat solution for the view switcher in java, which seems to work excellently after a direct port to C#. Some adjustments need to be made today, like triggering the update of the header when the view changes, the header size, and an issue where the view is slightly off after flipping the phone horizontal.
We have an issue where the login info settings would not be stored correctly, and so this will be addressed today. Also, some thought was given to how the model should behave when settings change. We decided that the model should contain all logic for keeping track of state and reloading, possibly with an event the view can listen to. This becomes an issue especially for the android platform, where settings can be changed without the model knowing right away. Anyway, it will be to task of the model to always present a consistent set of data, reloading when needed (or explicit calls to Load()).
Great. Hopefully the refactorings in the model will give us a better idea of exactly how the model interacts with the HTTP services. Once we have finished that part, we will know what HTTP services to implement on the server-side, and this can be done later this week. -Alex.
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.