Currently flutter only works on MainActivity. We need to implement some system to make flutter calls from background service.

Currently we queue all packets sent to the watch. We should not queue AppMessage packets to mimic classic Pebble app behavior in that regard.

I will create a workable UI prototype in Figma that performs all of the listed functions in the milestones below. The figma file is located at https://www.figma.com/file/mXl0svBSnlGV2MKfTj8H7e/Mobile-app?node-id=121%3A424

• Support/Community links page

  • Rebble support email
  • Share app logs (moved to Analytics screen)
  • Discord server
  • Subreddit

• Developer features

  • Connect to a PC running SDK tools
  • View logs from apps on connected watch Feature dropped, maybe? I finished the prototype either way
  • Take screenshot of watch

Needs to be done since we changed the codename to avoid confusion with the Fossil watchmaker.

Current app already has rudimentary PebbleKit support, but following still needs to be done:

• Fill Pebble content provider with real data (depends on #17)
• Only send app messages for currently open app
• Implement AppMessage logs
• Implement screenshot packet
• Connect / Disconnect intent

After this is done, all remote-related features of the pebble command in the Pebble SDK should work.

Currently all strings in the app are hardcoded english. At some point, we should add https://flutter.dev/docs/development/accessibility-and-localization/internationalization to the project.

Minor optimization - when user disconnects from the watch, nothing from Cobble app should be running in the background.

Currently unregistering/forgetting a device only removed it from PairedStorage but does not unpair the device

I think logging (especially file logging) should be left to the native since it can run all the time. But Flutter code should have a way to hook into it and transmit logs.

We should display an error message or something. Low priority.

Can be tested on Android Emulator.

Currently a release build fails with the following:

/home/crc32/Documents/fossil/build/app/tmp/kapt3/stubs/release/io/rebble/fossil/di/AppComponent.java:8: error: [Dagger/DependencyCycle] Found a dependency cycle:
public abstract interface AppComponent {
                ^
      error.NonExistentClass is injected at
          io.rebble.fossil.di.LibPebbleModule.provideBlobDbService(protocolHandler)
      error.NonExistentClass is requested at
          io.rebble.fossil.di.AppComponent.createProtocolHandler()

Depends on #27

I will create a workable UI prototype in Figma that performs all of the listed functions in the milestones below. The figma file is located at https://www.figma.com/file/mXl0svBSnlGV2MKfTj8H7e/Mobile-app?node-id=121%3A424

• Enable and disable the feature
• Display steps, sleep, and heart rate data
• Log in/log out of google fit to sync data
• Manage health database
  • Import
  • Export
  • Delete

I will create a workable UI prototype in Figma that performs all of the listed functions in the milestones below. The figma file is located at https://www.figma.com/file/mXl0svBSnlGV2MKfTj8H7e/Mobile-app?node-id=121%3A424

• Onboard new users

  • Ask for permissions
  • Pair with a watch
    • Bluetooth LE/Bluetooth classic scanning
    • Other pairing methods (manual Bluetooth address entry)
  • Flash a recovery mode watch with firmware
  • Set up RWS
  • Setup language
  • Setup health

• Core features

  • Manage notification mirroring
    • Enable and disable notification mirroring per app
    • Silence phone when connected to watch (calls, notifications)
  • Manage connectivity
    • Pair additional watches
    • Switch connected device
    • Update device firmware
  • Manage calendars
  • Canned messages/favorite contacts in built in SMS app
  • Analytics optout/in

I will complete tasks in the Basics and Apps milestones that have not been taken by the @crc-32 yet:

Milestone 1:

• Sync phone time to the watch (#16)
• Calendar sync (#26)
• Music Control (#25)

Milestone 2:

• App installation fro pbw file (#33)

• Store app locker on the phone (#34 - This task is prerequisite for both me and @crc-32. We have agreed that whoever needs it first, implements it)

• Complete PebbleKit Android implementation (#37)

• Add support for Sports and Golf apps (#38)

• Complete developer connection implementation (#47)

• ✖️ Add Data Logging support (#39) WON'T DO

Limitations

• Everything here applies to Android only. While I will try to implement as much features as possible in flutter, which is shared between Android and iOS, iOS developer will still need to connect all of those features with the iOS.
• This does not include proper UI, since designs are still being done (#43) and to be frank, I need to get some experience with Flutter UI first. As the part of this grant, I will add some rudimentary UI to the app that will allow use of the features, but it will not look or feel good. Proper "fancy" UI can be implemented after the fact.

Depends on #45

Sync should happen:

• Every time watch connects
• Every time phone's time changes (for example when user enter a new timezone)

This is fairly trivial, so I think we should implement it native-only (no flutter)

After watch connects, we should fetch:

• Model
• Color
• Firmware version

of the watch and make it available inside phone app (for the display in the "My Watch" menu and for AppMessage purposes).

Line 23
onGenerateRoute: Router.generateRoute,
showing error.
{ "resource": "/Users/kent/Developer/mobile-app/lib/main.dart", "owner": "dart", "code": { "value": "ambiguous_import", "target": { "$mid": 1, "external": "https://dart.dev/tools/diagnostic-messages#ambiguous_import", "path": "/tools/diagnostic-messages", "scheme": "https", "authority": "dart.dev", "fragment": "ambiguous_import" } }, "severity": 8, "message": "The name 'Router' is defined in the libraries 'package:flutter/src/widgets/router.dart' and 'package:fossil/ui/Router.dart'.\nTry using 'as prefix' for one of the import directives, or hiding the name from all but one of the imports.", "source": "dart", "startLineNumber": 23, "startColumn": 24, "endLineNumber": 23, "endColumn": 30, "tags": [] }

• Add native implementation on Android
• Add UI to flutter

Note that deigns on this are incomplete. On Android we have two stages of this option: first stage only mutes notifications while second stage also mutes phone calls. Current designs only display single toggle.

Depends on #15

At the moment, Location permission is only required before user scans for the watches (in the future, this will also be used for PKJS ).

App should sync all user's calendar events to the watch's timeline.

• When event is added or removed from the phone's calendar, watch should be updated as fast as possible.
• When watch disconnects and then reconnect, all changed events should be synced to the watch upon connecting

User should also be able to select which calendars should be synced.

Depends on #15

It should work somewhat like this:

1. Android native side detects whenever user's calendar changes
2. It transmits that to the Flutter side
3. Flutter merges new events with existing calendar db
4. Flutter transmits any changes to the watch, if necessary

Actions that should be on timeline pins:

• Cancel
• Remove (presumably just hides the event?)
• Mute Calendar

Sub-tasks (WIP in https://github.com/matejdro/mobile-app/tree/calendar):

• Allow user to select / deselect calendars to sync
• Sync calendar to the app's internal database when user presses a button
• Send app's internal database to the watch
• Add support for whole day events
• Sync dynamically when event is added/updated/removed from the calendar
• Properly load calendar list on background sync
• Resync every day to capture new events out of 3 day window.
• Filter out HTML from calendar descriptions
• Add support for multi-day events
• Retry watch sync later if blobdb reports error
• Add Remove and Mute calendar actions
• Add event participation calendar actions
• Code quality: rename constants and enums to camelCase to conform to dart guidelines
• Improve error handling
• Also sync past events
• Document isVisible (if pin is visible) and persistQuickView (if quick view is persisted during event duration) timeline flags do
• Nuke blobdb on the watch whenever watch reconnects and it is unfaithful
• Nuke blobdb on the watch whenever watch user switches watches
• Re-sync calendar after user grants calendar permission
• Re-sync calendar after user selects different calendars
• Increase timeline sync window so the watch still gets future calendar events even when disconnected
• Delete pins before adding new ones to make room for new pins in case of full storage
• Sync older pins first to ensure user gets earliest events first in case of full storage
• Add checkbox to the app to enable/disable sync completely

Probably only needed on Android.

Prompt needs to be displayed:

1. After watch is paired
2. After every start of the app if service is not active (with "Do not ask me again" option).

Note that after our prompt, system prompt will show up asking user if he allows Cobble to access notifications.

Very low priority since there are no firmwares out yet.

Those apps are basically just regular apps that communicate via AppMessage. What needs to be added is customization feature that allows mobile apps to change the name of the app (so apps would say "Strava" instead of just generic "Sports" for example).

I'm not aware of any Android app that uses golf, but in the worst case, I will whip some testing app myself so I can test this feature out.

I will create a workable UI prototype in Figma that performs all of the listed functions in the milestones below. The figma file is located at https://www.figma.com/file/mXl0svBSnlGV2MKfTj8H7e/Mobile-app?node-id=121%3A424

• Manage owned watch faces
• Manage owned watch apps
• Configure watch apps and faces
• Manage permissions for watch apps and faces
• Install new apps from RWS appstore
  • Search bar and browser controls when necessary (legacy app store)

I will create a workable UI prototype in Figma that performs all of the listed functions in the milestones below. The figma file is located at https://www.figma.com/file/mXl0svBSnlGV2MKfTj8H7e/Mobile-app?node-id=121%3A424

• Onboard new users

  • Ask for permissions
  • Pair with a watch
  • Flash a recovery mode watch with firmware
  • Set up RWS
  • Setup language
  • Setup health

• Core features

  • Manage notification mirroring
    • Silence phone when connected to watch (calls, notifications)
  • Manage connectivity
    • Pair additional watches
    • Switch connected device
    • Update device firmware
  • Manage calendars
  • Canned messages/favorite contacts in built in SMS app
  • Analytics optout/in

• Locker

  • Manage owned watch faces
  • Manage owned watch apps
  • Configure watch apps and faces
  • Manage permissions for watch apps and faces
  • Install new apps from RWS appstore

• Health

  • Enable and disable the feature
  • Display steps, sleep, and heart rate data
  • Log in/log out of google fit to sync data
  • Manage health database
    • Import
    • Export
    • Delete

• Support/Community links page

  • Support email
  • Share app logs
  • Discord server
  • Subreddit

• Developer features

  • Connect to a PC running SDK tools
  • View logs from apps on connected watch
  • Take screenshot of watch

This would make development much easier since I won't have to go to devices and wait for scan completion to test anything. I can take a stab at it if you wish.

Similarly to original Pebble app, new app should also be able to install pebble apps from pbw files.

Upon tapping on pwb file in any file browser app (or in browser's downloads list), Cobble app should open, displaying information about the app and offering user to install it.

Progress in https://github.com/pebble-dev/mobile-app/tree/pbw_install:

Stage 1:

• Native - Open and read PBW file metadata (Flutter has no appropriate zip library)
• Flutter - Display rudimentary install confirmation prompt
• Flutter Native - Copy file to the app storage

Stage 2:

• Flutter - Insert app into BlobDB
• Flutter - Open app on the watch
• Native - Send app data to the watch on request
• Flutter - Display installation progress
• Flutter - Add delete app button
• Both - Delete PBW file upon deleting app

Stage 3:

• Flutter - organize background code (split into multiple files)
• Flutter - Close install dialog when install is complete
• Flutter - Clear and reinstall all apps when watch is unfaithful
• Flutter - Fail gracefully if app does not support connected watch
• Flutter - Force reinstall when installing already installed pbw
• Flutter - Display message to the user if watch is not connected
• Flutter - display app compatibility
• Filter pbw intents to only content uris

Prerequisite components

• Cupertino navigation #84
• Material theming and components #90
  • button
  • FAB button
  • card (with support for theming)
  • bottom sheet
  • modal dialog (with support for theming)

Settings screen #90

• Rebble account card
• Custom list tiles
  Notifications screen #90
• Custom list tiles, some are reusable, some are specific to this screen
  Alerting apps screen #90
• We need native plugin to support NotificationListener, work on that is tracked in #94
• Inline bottom sheet (it's different than modal bottom sheet)
• Search implementation
  Health screen #90
• Expandable list tile
• Custom list tiles, mostly reusable from other screens
• Rebble account card (smaller version, different actions)
• Modal bottom sheet with another ListView

Just a small request: Could you export your code style config from Android Studio and commit it into project? That way there aren't any code style discrepancies with external commits.

Depends on #15

At the moment, there are two ways to do this on Android:

• The old Bluetooth Intent way (like original Pebble app) - This allows user to pick one app in the settings (or on the watch) and always control that app. Big pro of this method is that user can start playback even when app is not active. Con is that many modern music players (such as Youtube Music or Google Podcasts) do not support that anymore, so user cannot control those apps.

• New Notification Service way. This one is more modern and supports pretty much all media apps. Con of this is that it only controls last active app (user cannot switch between Podcasts and Spotify for example). Also this method has more information on playback (such as current position in track).

Which path should we take? I lean for for the second option.

This is to allow people to test the app without us manually sending APKs.

Ideally, at this early stage, location of these builds should be a bit secluded, so only people that know what are doing can get the build (and we are not swamped by lots of bug reports on unfinished app).

Watch data needs to be stored after first connection to watch so it can be accessed in the My Watches page.

Add support for Data Logging: https://developer.rebble.io/developer.pebble.com/guides/communication/datalogging/index.html

I'm not aware of any Android app that actually uses this, but in the worst case, I will whip some testing app myself so I can test this feature out.

Currently notification access code is very crude and lets through most notifications (including ones that shouldn't be on the watch such as Play Store updates).

We should improve that logic.

Most of the backend for that screen is ready and could be done.

Missing features at the moment:

• Current firmware version and watch model for non-BLE connections (#17)
• Firmware update (#23)

• Determining information (model, colour, etc.) and displaying on pair list (e58b717)
  • Determine info
  • Display on pair list
• Pairing with LE only watch
• PPoGATT client implementation (subscribing to data characteristic to receive packets, writing packets to data characteristic)
  • Handling PPoGATT packets and forwarding Pebble protocol data packets to libpebblecommon
  • Write callback for libpebblecommon to send Pebble protocol data packets
• If necessary, logic for pairing with hybrid LE and classic watch
• PPoGATT server implementation (provides service for watch to send packets to / receive packets as a replacement for client mode, avoids all apps seeing PPoGATT activity)
• Validate via pairing a BLE watch from scratch and testing PingPong endpoint in both client and server mode.