Source: js/devtools/logshake.js

  1. /* global dump,
  2.           ModalDialog,
  3.           MozActivity,
  4.           Notification,
  5.           Service
  6. */
  8. (function(exports) {
  9.   'use strict';
  11.   const DEBUG = false;
  13.   /**
  14.    * This developer system module captures a snapshot of the current device
  15.    * logs as displayed by logcat using DeviceStorage to persist the file for
  16.    * future access. It communicates with gecko code running in
  17.    * b2g/chrome/content/shell.js using a SystemAppProxy custom event based API.
  18.    * It requires the preference 'devtools.logshake' to be enabled
  19.    *
  20.    * @class LogShake
  21.    */
  22.   function LogShake() {
  23.   }
  25.   function debug(str) {
  26.     if (DEBUG) {
  27.       dump('LogShake: ' + str + '\n');
  28.     }
  29.   }
  31.   LogShake.prototype = {
  32.     /**
  33.      * Start existing, observing for capture-logs events caused by Gecko
  34.      * LogShake
  35.      */
  36.     start: function() {
  37.       Service.request('handleSystemMessageNotification', 'logshake', this);
  38.       window.addEventListener('volumeup+volumedown', this);
  39.       this.startCaptureLogsListener();
  40.     },
  42.     /**
  43.      * Stop the component, removing all listeners if necessary
  44.      */
  45.     stop: function() {
  46.       Service.request('unhandleSystemMessageNotification', 'logshake', this);
  47.       this.stopCaptureLogsListener();
  48.     },
  50.     startCaptureLogsListener: function() {
  51.       debug('starting captureLogs listener');
  52.       window.addEventListener('capture-logs-start', this);
  53.       window.addEventListener('capture-logs-success', this);
  54.       window.addEventListener('capture-logs-error', this);
  55.     },
  57.     stopCaptureLogsListener: function() {
  58.       debug('stopping captureLogs listener');
  59.       window.removeEventListener('capture-logs-start', this);
  60.       window.removeEventListener('capture-logs-success', this);
  61.       window.removeEventListener('capture-logs-error', this);
  62.     },
  64.     /**
  65.      * Handle a capture-logs-start, capture-logs-success or capture-logs-error
  66.      * event, dispatching to the appropriate handler
  67.      */
  68.     handleEvent: function(event) {
  69.       debug('handling event ' + event.type);
  70.       switch(event.type) {
  71.         case 'volumeup+volumedown':
  72.           this.requestSystemLogs();
  73.           break;
  74.         case 'capture-logs-start':
  75.           this.handleCaptureLogsStart(event);
  76.           break;
  77.         case 'capture-logs-success':
  78.           this.handleCaptureLogsSuccess(event);
  79.           break;
  80.         case 'capture-logs-error':
  81.           this.handleCaptureLogsError(event);
  82.           break;
  83.       }
  84.     },
  86.     _shakeId: null,
  87.     handleCaptureLogsStart: function(event) {
  88.       debug('handling capture-logs-start');
  89.       this._shakeId = Date.now();
  90.       this._notify('logsSaving', '');
  91.     },
  93.     requestSystemLogs: function() {
  94.       window.dispatchEvent(new CustomEvent('requestSystemLogs'));
  95.     },
  97.     /**
  98.      * Handle an event of type capture-logs-success. event.detail.locations is
  99.      * an array of absolute paths to the saved log files, and
  100.      * event.detail.logFolder is the folder name where the logs are located.
  101.      */
  102.     handleCaptureLogsSuccess: function(event) {
  103.       debug('handling capture-logs-success');
  104.       navigator.vibrate(100);
  105.       this._notify('logsSaved', 'logsSavedBody',
  106.                    this.triggerShareLogs.bind(this, event.detail.logFilenames),
  107.                    event.detail);
  108.       this._shakeId = null;
  109.     },
  111.     handleCaptureLogsError: function(event) {
  112.       debug('handling capture logs error');
  113.       var error    = event ? event.detail.error : '';
  114.       var errorMsg = this.formatError(error);
  115.       this._notify('logsSaveError', errorMsg,
  116.                    this.showErrorMessage.bind(this, error),
  117.                    event.detail);
  118.       this._shakeId = null;
  119.     },
  121.     getDeviceStorage: function() {
  122.       var storageName = 'sdcard';
  123.       var storages = navigator.getDeviceStorages(storageName);
  124.       for (var i = 0; i < storages.length; i++) {
  125.         if (storages[i].storageName === storageName) {
  126.           return storages[i];
  127. 	}
  128.       }
  129.       return navigator.getDeviceStorage('sdcard');
  130.     },
  132.     triggerShareLogs: function(logFilenames, notif) {
  133.       var logFiles = [];
  134.       var storage = this.getDeviceStorage();
  135.       var requestsRemaining = logFilenames.length;
  136.       var self = this;
  138.       if (notif) {
  139.         notif.close();
  140.       }
  142.       function onSuccess() {
  143.         /* jshint validthis: true */
  144.         logFiles.push(this.result);
  145.         requestsRemaining -= 1;
  146.         if (requestsRemaining === 0) {
  147.           var logNames = logFiles.map(function(file) {
  148.             // For some reason file.name contains the full path despite
  149.             // File's documentation explicitly stating the opposite.
  150.             var pathComponents = file.name.split('/');
  151.             return pathComponents[pathComponents.length - 1];
  152.           });
  153.           /* jshint nonew: false */
  154.           new MozActivity({
  155.             name: 'share',
  156.             data: {
  157.               type: 'application/vnd.moz-systemlog',
  158.               blobs: logFiles,
  159.               filenames: logNames
  160.             }
  161.           });
  162.         }
  163.       }
  165.       function onError() {
  166.         /* jshint validthis: true */
  167.         self.handleCaptureLogsError({detail: {error: this.error}});
  168.       }
  170.       for (var logFilename of logFilenames) {
  171.         var req = storage.get(logFilename);
  172.         req.onsuccess = onSuccess;
  173.         req.onerror = onError;
  174.       }
  175.     },
  177.     ERRNO_TO_MSG: {
  178.        0: 'logsGenericError',
  179.       30: 'logsSDCardMaybeShared' // errno: filesystem ro-mounted
  180.     },
  182.     formatError: function(error) {
  183.       if (typeof error === 'string') {
  184.         return error;
  185.       }
  187.       if (typeof error === 'object') {
  188.         if ('operation' in error) {
  189.           return navigator.mozL10n.get('logsOperationFailed',
  190.                                        { operation: error.operation });
  191.         }
  192.       }
  194.       return '';
  195.     },
  197.     showErrorMessage: function(error, notif) {
  198.       if (notif) {
  199.         notif.close();
  200.       }
  202.       // Do nothing for error string
  203.       if (typeof error === 'string') {
  204.         return;
  205.       }
  207.       if (typeof error !== 'object') {
  208.         console.warn('Unexpected error type: ' + typeof error);
  209.         return;
  210.       }
  212.       // Small heuristic for some frequent unix error cases
  213.       if ('unixErrno' in error) {
  214.         var errno = error.unixErrno;
  215.         debug('errno: ' + errno);
  217.         // Gracefully fallback to a generic error messages if we don't know
  218.         // this errno code.
  219.         if (!this.ERRNO_TO_MSG[errno]) {
  220.           errno = 0;
  221.         }
  223.         ModalDialog.alert('logsSaveError',
  224.                           this.ERRNO_TO_MSG[errno], { title: 'ok' });
  225.       }
  226.     },
  228.     _notify: function(titleId, body, onclick, dataPayload) {
  229.       var title = navigator.mozL10n.get(titleId) || titleId;
  230.       var payload = {
  231.         body: navigator.mozL10n.get(body) || body,
  232.         tag: 'logshake:' + this._shakeId,
  233.         data: {
  234.           systemMessageTarget: 'logshake',
  235.           logshakePayload: dataPayload || undefined
  236.         }
  237.       };
  238.       var notification = new Notification(title, payload);
  239.       if (onclick) {
  240.         notification.onclick = onclick.bind(this, notification);
  241.       }
  242.     },
  244.     handleSystemMessageNotification: function(message) {
  245.       debug('Received system message: ' + JSON.stringify(message));
  246.       this.closeSystemMessageNotification(message);
  248.       if (!('logshakePayload' in message.data)) {
  249.         console.warn('Received logshake system message notification without ' +
  250.                      'payload, silently discarding.');
  251.         return;
  252.       }
  254.       debug('Message payload: ' + message.data.logshakePayload);
  255.       var payload = message.data.logshakePayload;
  256.       if ('error' in payload) {
  257.         this.showErrorMessage(payload.error);
  258.       } else if ('logFilenames' in payload) {
  259.         this.triggerShareLogs(payload.logFilenames);
  260.       } else {
  261.         console.warn('Unidentified payload: ' + JSON.stringify(payload));
  262.       }
  264.     },
  266.     closeSystemMessageNotification: function(msg) {
  267.       Notification.get({ tag: msg.tag }).then(notifs => {
  268.         notifs.forEach(notif => {
  269.           if (notif.tag) {
  270.             // Close notification with the matching tag
  271.             if (notif.tag === msg.tag) {
  272.               notif.close && notif.close();
  273.             }
  274.           }
  275.         });
  276.       });
  277.     }
  278.   };
  280.   exports.LogShake = LogShake;
  282.   // XXX: See issue described in screenshot.js
  283.   exports.logshake = new LogShake();
  284.   exports.logshake.start();
  285. })(window);