virb3.py

#!/usr/bin/python3
# -*- coding: utf8 -*-
"""Python 3 Module to interact with Garmin Virb cameras over wifi / mass storage
This module also allows you to interact with the Garmin website and
fetch firmware updates when you don't feel like using the Garmin supplied
windows or Mac software.

I can't give you any warranty that any of these things will work,
especially the firmware upgrades could be dangerous.
"""
__author__ = 'Jan KLopper (jan@underdark.nl)'
__version__ = 0.2

import os
import simplejson
import requests

class Virb(object):
  """Class to interact with Garmin Virb cameras over wifi / http"""
  def __init__(self, host=('192.168.0.1', 80)):
    """Sets up the connection with the Virb device

    Accepts an ip and port which should be routable from the device running
    the code.

    host = ('192.168.0.1', 80)
    """
    self.host = host
    self.requestcount = 0

  def status(self):
    """Returns the current camera status"""
    command = 'status'
    data = {'command': command}
    return self._do_post(data=data)

  def features(self):
    """Returns the features"""
    command = 'features'
    data = {'command': command}
    return self._do_post(data=data)[command]

  def get_features(self):
    """Returns the features list as a dictionary"""
    features = self.features()
    results = {'enabled': {},
               'disabled': {}}
    for feature in features:
      name = str(feature['feature'])
      value = feature['value']
      try:
        value = int(value)
      except ValueError:
        value = str(value)
      if feature['enabled']:
        results['enabled'][name] = value
      else:
        results['disabled'][name] = value
    return results

  def set_features(self, feature, value):
    """Update a features"""
    command = 'updateFeature'
    data = {'command': command,
            'feature': feature,
            'value': value}
    return self._do_post(data=data)['features']

  def sensors(self):
    """Returns the current camera sensor readings"""
    command = 'sensors'
    data = {'command': command}
    sensors = self._do_post(data=data)
    if not sensors:
      raise VirbNoSensors('no Sensors are currently available')

  def device_info(self):
    """Returns the cameras device info"""
    command = 'deviceInfo'
    data = {'command': command}
    return self._do_post(data=data)[command]

  def locate(self):
    """Starts the camera emmiting its lost sound/flash"""
    command = 'locate'
    data = {'command':command}
    return bool(int(self._do_post(data=data)['result']))

  def found(self):
    """Stops the camera emmiting its lost sound/flash"""
    command = 'found'
    data = {'command':command}
    return bool(int(self._do_post(data=data)['result']))

  def media_dir_list(self):
    """Returns the list of media directories on the device"""
    command = 'mediaDirList'
    data = {'command':command}
    return self._do_post(data=data)#['mediaDirs']

  def media_list(self, path=None):
    """Returns the list of media directories on the device"""
    command = "mediaList"
    data = {'command':command}
    if path:
      data['path'] = path
    return self._do_post(data=data)['media']


  def live_preview(self, streamtype="rtp"):
    """Returns the cameras live preview url"""
    command = 'livePreview'
    data = {'command':command,
            'streamType':streamtype}
    return self._do_post(data=data)['url']

  def snap_picture(self, timer=0):
    """Take a picture"""
    command = 'snapPicture'
    data = {'command':command,
            'selfTimer':timer}
    return self._do_post(data=data)

  def start_recording(self):
    """Start recording"""
    command = "startRecording"
    data = {'command':command}
    return bool(int(self._do_post(data=data)['result']))

  def stop_recording(self):
    """Stop recording"""
    command = 'stopRecording'
    data = {'command':command}
    return bool(int(self._do_post(data=data)['result']))

  def stop_stil_tecording(self):
    """Stop recording still images"""
    command = 'stopStillRecording'
    data = {'command':command}
    return bool(int(self._do_post(data=data)['result']))

  def _do_post(self, url='virb', data=None):
    url = 'http://%s:%d/%s' % (self.host[0], self.host[1], url)
    request = requests.post(url, data=simplejson.dumps(data))
    self.requestcount += 1
    try:
      return request.json()
    except simplejson.scanner.JSONDecodeError:
      return request.text


class VirbUsb(object):
  """Class to interact with Garmin Virb devices over USB"""
  def __init__(self, device):
    """Sets the USB device path as seen on the filesystem

    For example:
    device = /media/garmin-virb"""
    self.device = device

  def get_log(self):
    """Yields a list of log entries on the device"""
    logfile = open('%s/Garmin/elog.txt' % self.device, 'r')
    logentry = []
    for line in logfile.readline():
      if line:
        logentry.append(line)
      if line == '-----------------------------------------':
        yield logentry
        logentry = []

  def clear_log(self):
    """Clears the log entries on the device"""
    logfile = open('%s/Garmin/elog.txt' % self.device, 'w')
    logfile.close()
    return True

  def get_tracks(self):
    """Lists all the gpx tracks on the devices"""
    trackpath = '%s/Garmin/GPX' % self.device
    fileslist = os.listdir(trackpath)
    return [filename for filename in fileslist
            if os.path.isfile(os.path.join(trackpath, filename))]

  def get_activity(self):
    """Lists all FIT activity files on the device

    Use https://github.com/dtcooper/python-fitparse to parse these files into
    something meaningfull. Or install fitparse using pip: `pip install fitparse`
    """
    activitypath = '%s/Garmin/Activity' % self.device
    fileslist = os.listdir(activitypath)
    return [filename for filename in fileslist
            if os.path.isfile(os.path.join(activitypath, filename))]

  def get_media(self, extensions=('jpg', 'mp4')):
    """Lists all pictures/videos on the devices

    Possibly filter on extensions (lowercase) using the extensions argument as
      a tuple
    """
    mediapath = '%s/DCIM/100_VIRB' % self.device
    fileslist = os.listdir(mediapath)
    return [filename for filename in fileslist
            if (os.path.isfile(os.path.join(mediapath, filename)) and
                filename[-3:].lower() in extensions)]

  def update_firmware(self, version=None):
    """This Upgrades the firmware on the Virb

    It follows the known update procedure but handles everything on its own.

    GCD Update Procedure

    Use the links in Firmware History to download the zipped file for the
    version you need.
    (https://www8.garmin.com/support/download_details.jsp?id=6565)
    Unzip the downloaded archive and extract the gcd file
    Rename the gcd file to gupdate.gcd
    Connect the VIRB to your computer via usb
    Copy the gupdate.gcd file to [µSD]/Garmin/gupdate.gcd
    Disconnect and reboot the VIRB
    Once the update is completed, the VIRB will delete the gupdate.gcd file"""
    if version:
      garmin = Garmin()
      firmware = garmin.get_firmware(version=version)
      targetpath = '%s/Garmin/gupdate-.gcd' % self.device
      print('Writing out data to device, do not reboot / power down')
      targetfile = open(targetpath, 'w')
      targetfile.write(firmware)
      print('Finishing writing out data to device, do not reboot / power down')
      os.fsync(targetfile)
      targetfile.close()
      print('All Done. Please reboot the Virb')
      return True
    return False


class Garmin(object):
  """Class to namespace any Garmin specific funtions and methods that have no
  direct use for any specific device information"""
  @staticmethod
  def get_firmware(device="VIRB", version=4.00):
    """Version as float"""
    return requests.get("https://download.garmin.com/software/%s_%d.gcd" % (
        device, int(version*100)))

class VirbError(Exception):
  """General exception class for Virb camera class"""


class VirbNoSensors(VirbError):
  """No sensors where located / enabled / connected to the Virb"""


if __name__ == '__main__':
  camera = Virb()
  print(repr(camera.status()))
  print(repr(camera.device_info()))
  print(repr(camera.features()))
  print(repr(camera.get_features()))
  try:
    print(repr(camera.sensors()))
  except VirbNoSensors:
    print('no sensors connected')
  print(repr(camera.media_dir_list()))
  #print(repr(camera.SnapPicture()))