+
+ ///
+ /// Write a listing of the stored recordings to @p tx_buf.
+ pub fn list_recordings(&mut self, tx_buf: &mut Buffer) {
+ for index in self.sector_header_iter().rev() {
+ let sector_header = &self.sector_header[index as usize];
+
+ if !sector_header.starts_recording() {
+ continue;
+ }
+
+ let mut num_data_sectors = 0;
+
+ for d in 1..NUM_SECTORS {
+ let wrapped_index = ((index + d) & (NUM_SECTORS - 1)) as usize;
+ let other_sector_header = &self.sector_header[wrapped_index];
+
+ if other_sector_header.belongs_to(sector_header.recording_id) {
+ num_data_sectors += 1;
+ }
+ }
+
+ let mut date_time_s = [b' '; 19];
+
+ if let Some(tm) = Time::from_unix_time(sector_header.start_time) {
+ tm.fmt_date(&mut date_time_s[0..]);
+ tm.fmt_time(&mut date_time_s[11..]);
+ }
+
+ let recording_size = (num_data_sectors + 1) * (SECTOR_SIZE >> 10);
+
+ let mut recording_size_s = [b'0'; 9];
+ let recording_size_s_len = fmt_u32_pad(&mut recording_size_s,
+ recording_size as u32,
+ 8, b' ');
+
+ let mut recording_id_s = [b'0'; 9];
+ let recording_id_s_len =
+ fmt_u32_pad(&mut recording_id_s,
+ sector_header.recording_id as u32,
+ 8, b' ');
+
+ tx_buf.write(&date_time_s);
+ tx_buf.write(&recording_size_s[0..recording_size_s_len]);
+ tx_buf.write(b"K");
+ tx_buf.write(&recording_id_s[0..recording_id_s_len]);
+ tx_buf.write(b"\n");
+
+ tx_buf.flush();
+ }
+ }
+
+ ///
+ /// Check whether or not recording @p recording_id exists.
+ pub fn has_recording(&mut self, recording_id: u16) -> bool {
+ if recording_id == 0 {
+ return false;
+ }
+
+ self.sector_header_iter().find(|&index| {
+ let sector_header = &self.sector_header[index as usize];
+
+ sector_header.recording_id == recording_id &&
+ sector_header.starts_recording()
+ }).is_some()
+ }
+
+ ///
+ /// Retrieve recording @p recording_id and
+ /// write it to @p tx_buf in yencoded form.
+ pub fn get_recording(&mut self, recording_id: u16,
+ tx_buf: &mut Buffer) -> Result<(), Error> {
+ if recording_id == 0 {
+ return Err(Error::NoSuchRecording);
+ }
+
+ if let Some(found_index) = self.sector_header_iter().find(|&index| {
+ let sector_header = &self.sector_header[index as usize];
+
+ sector_header.recording_id == recording_id &&
+ sector_header.starts_recording()
+ }) {
+ let mut filename = [b' '; 29];
+
+ filename[0..].copy_from_slice(b"gps-watch-recording-XXXXX.bin");
+
+ fmt_u32_pad(&mut filename[20..], recording_id as u32, 5, b'0');
+
+ let mut yenc = Yencode::new(tx_buf);
+
+ yenc.start(&filename);
+
+ let format_version = 1u8;
+ yenc.data(&[format_version]);
+
+ let mut next_sector = found_index as usize;
+
+ for _ in 0..NUM_SECTORS {
+ let address = next_sector * SECTOR_SIZE;
+ let mut buf = [0u8; SECTOR_SIZE];
+
+ self.storage.read(address, &mut buf);
+
+ // Skip flags and recording ID.
+ yenc.data(&buf[4..]);
+
+ next_sector += 1;
+ next_sector &= NUM_SECTORS - 1;
+
+ if !self.sector_header[next_sector].belongs_to(recording_id) {
+ break;
+ }
+ }
+
+ yenc.finish();
+
+ tx_buf.flush();
+
+ Ok(())
+ } else {
+ Err(Error::NoSuchRecording)
+ }
+ }
+
+ ///
+ /// Remove recording @p recording_id.
+ pub fn remove_recording(&mut self, recording_id: u16) -> Result<(), Error> {
+ if let Some(found_index) = (0..NUM_SECTORS).find(|&index| {
+ let sector_header = &self.sector_header[index as usize];
+
+ sector_header.recording_id == recording_id &&
+ sector_header.starts_recording()
+ }) {
+ let mut next_sector = found_index as usize;
+
+ for _ in 0..NUM_SECTORS {
+ let address = next_sector * SECTOR_SIZE;
+
+ if let Err(_) = self.storage.erase(address) {
+ return Err(Error::StorageError);
+ }
+
+ // Mark this sector as eligible for the next recording
+ // and ensure it won't be picked up by list_recordings().
+ self.read_sector_header(next_sector);
+
+ next_sector += 1;
+ next_sector &= NUM_SECTORS - 1;
+
+ if !self.sector_header[next_sector].belongs_to(recording_id) {
+ break;
+ }
+ }
+
+ Ok(())
+ } else {
+ Err(Error::NoSuchRecording)
+ }
+ }