LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Remove emacs scripts"

Browse Source 
am: 996f9b13a0

Change-Id: Ic55022dcaf960b1d81e745356edc14b3ad5b6f9c
This commit is contained in:
Dan Willemsen
2019-07-19 07:38:08 -07:00
committed by android-build-merger
parent 1b8dd7a00d 996f9b13a0
commit ddf9c9bbeb
3 changed files with 0 additions and 469 deletions
Download Patch File Download Diff File Expand all files Collapse all files

181
ide/emacs/android-common.el
View File

@@ -1,181 +0,0 @@
;;; android-common.el --- Common functions/variables to dev Android in Emacs.
;;
;; Copyright (C) 2009 The Android Open Source Project
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;; http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.
;;; Commentary:
;;
;; Variables to customize and common functions for the Android build
;; support in Emacs.
;; There should be no interactive function in this module.
;;
;; You need to have a proper buildspec.mk file in your root directory
;; for this module to work (see $TOP/build/buildspec.mk.default).
;; If the path the product's files/image uses an a product alias, you
;; need to add a mapping in `android-product-alias-map'. For instance
;; if TARGET_PRODUCT is foo but the build directory is out/target/product/bar,
;; you need to add a mapping Target:foo -> Alias:bar
;;
;;; Code:
(defgroup android nil
"Support for android development in Emacs."
:prefix "android-" ; Currently unused.
:tag "Android"
:group 'tools)
;;;###autoload
(defcustom android-compilation-jobs 2
"Number of jobs used to do a compilation (-j option of make)."
:type 'integer
:group 'android)
;;;###autoload
(defcustom android-compilation-no-buildenv-warning t
"If not nil, suppress warnings from the build env (Makefile,
bash) from the compilation output since they interfere with
`next-error'."
:type 'boolean
:group 'android)
;;;###autoload
(defcustom android-product-alias-map nil
"Alist between product targets (declared in buildspec.mk) and actual
product build directory used by `android-product'.
For instance if TARGET_PRODUCT is 'foo' but the build directory
is 'out/target/product/bar', you need to add a mapping Target:foo -> Alias:bar."
:type '(repeat (list (string :tag "Target")
(string :tag "Alias")))
:group 'android)
(defconst android-output-buffer-name "*Android Output*"
"Name of the default buffer for the output of the commands.
There is only one instance of such a buffer.")
(defun android-find-build-tree-root ()
"Ascend the current path until the root of the android build tree is found.
Similarly to the shell functions in envsetup.sh, for the root both ./Makefile
and ./build/core/envsetup.mk are exiting files.
Return the root of the build tree. Signal an error if not found."
(let ((default-directory default-directory))
(while (and (> (length default-directory) 2)
(not (file-exists-p (concat default-directory
"Makefile")))
(not (file-exists-p (concat default-directory
"build/core/envsetup.mk"))))
(setq default-directory
(substring default-directory 0
(string-match "[^/]+/$" default-directory))))
(if (> (length default-directory) 2)
default-directory
(error "Not in a valid android tree"))))
(defun android-project-p ()
"Return nil if not in an android build tree."
(condition-case nil
(android-find-build-tree-root)
(error nil)))
(defun android-host ()
"Return the <system>-<arch> string (e.g linux-x86).
Only linux and darwin on x86 architectures are supported."
(or (string-match "x86" system-configuration)
(string-match "i386" system-configuration)
(error "Unknown arch"))
(or (and (string-match "darwin" system-configuration) "darwin-x86")
(and (string-match "linux" system-configuration) "linux-x86")
(error "Unknown system")))
(defun android-product ()
"Return the product built according to the buildspec.mk.
You must have buildspec.mk file in the top directory.
Additional product aliases can be listed in `android-product-alias-map'
if the product actually built is different from the one listed
in buildspec.mk"
(save-excursion
(let* ((buildspec (concat (android-find-build-tree-root) "buildspec.mk"))
(product (with-current-buffer (find-file-noselect buildspec)
(goto-char (point-min))
(search-forward "TARGET_PRODUCT:=")
(buffer-substring-no-properties (point)
(scan-sexps (point) 1))))
(alias (assoc product android-product-alias-map)))
; Post processing, adjust the names.
(if (not alias)
product
(nth 1 alias)))))
(defun android-product-path ()
"Return the full path to the product directory.
Additional product aliases can be added in `android-product-alias-map'
if the product actually built is different from the one listed
in buildspec.mk"
(let ((path (concat (android-find-build-tree-root) "out/target/product/"
(android-product))))
(when (not (file-exists-p path))
(error (format "%s does not exist. If product %s maps to another one,
add an entry to android-product-map." path (android-product))))
path))
(defun android-find-host-bin (binary)
"Return the full path to the host BINARY.
Binaries don't depend on the device, just on the host type.
Try first to locate BINARY in the out/host tree. Fallback using
the shell exec PATH setup."
(if (android-project-p)
(let ((path (concat (android-find-build-tree-root) "out/host/"
(android-host) "/bin/" binary)))
(if (file-exists-p path)
path
(error (concat binary " is missing."))))
(executable-find binary)))
(defun android-adb ()
"Return the path to the adb executable.
If not in the build tree use the PATH env variable."
(android-find-host-bin "adb"))
(defun android-fastboot ()
"Return the path to the fastboot executable.
If not in the build tree use the PATH env variable."
; For fastboot -p is the name of the product, *not* the full path to
; its directory like adb requests sometimes.
(concat (android-find-host-bin "fastboot") " -p " (android-product)))
(defun android-adb-command (command &optional product)
"Execute 'adb COMMAND'.
If the optional PRODUCT is not nil, -p (android-product-path) is used
when adb is invoked."
(when (get-buffer android-output-buffer-name)
(with-current-buffer android-output-buffer-name
(erase-buffer)))
(if product
(shell-command (concat (android-adb) " -p " (android-product-path)
" " command)
android-output-buffer-name)
(shell-command (concat (android-adb) " " command)
android-output-buffer-name)))
(defun android-adb-shell-command (command)
"Execute 'adb shell COMMAND'."
(android-adb-command (concat " shell " command)
android-output-buffer-name))
(provide 'android-common)
;;; android-common.el ends here

166
ide/emacs/android-compile.el
View File

@@ -1,166 +0,0 @@
;;; android-compile.el --- Compile the Android source tree.
;;
;; Copyright (C) 2009 The Android Open Source Project
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;; http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.
;;; Commentary:
;;
;; Helper functions to compile Android file within emacs.
;; This module ignores 'build/envsetup.sh' and any enviroment set by the
;; 'lunch' shell function.
;; Instead it relies solely on 'buildspec.mk', remember that when you
;; switch configuration.
;;
;; The only interactive function is 'android-compile'.
;; In your .emacs load this file (e.g (require 'android-compile)) then:
;;
;; (add-hook 'c++-mode-hook 'android-compile)
;; (add-hook 'java-mode-hook 'android-compile)
;; and/or
;; (global-set-key [f9] 'android-compile)
;;
;;
;; TODO: Maybe we could cache the result of the compile function in
;; buffer local vars.
;;; Code:
(require 'compile)
(require 'android-common)
;; No need to be customized.
(defvar android-compile-ignore-re
"\\(^\\(\\sw\\|[/_]\\)+\\(Makefile\\|\\.mk\\):[0-9]+:.*warning\\)\\|\\(^/bin/bash\\)"
"RE to match line to suppress during a compilation.
During the compilation process line matching the above will be
suppressed if `android-compilation-no-buildenv-warning' is non nil.")
(defun android-makefile-exists-p (directory)
"Return t if an Android makefile exists in DIRECTORY."
; Test for Android.mk first: more likely.
(or (file-exists-p (concat directory "Android.mk"))
(file-exists-p (concat directory "Makefile"))))
(defun android-find-makefile (topdir)
"Ascend the current path until an Android makefile is found.
Makefiles are named Android.mk except in the root directory where
the file is named Makefile.
TOPDIR is the root directory of the build.
Return a list with 2 elements (MAKEFILE_PATH IS_ROOT_MAKEFILE).
MAKEFILE_PATH is the relative path of the makefile wrt TOPDIR.
Signal an error if no Makefile was found."
;; TODO: Could check that topdir is the start of default-directory.
(unless (> (length topdir) 2)
(error "Topdir invalid %s for current dir %s" topdir default-directory))
(let ((default-directory default-directory)
file)
;; Ascend the path.
(while (and (> (length default-directory) (length topdir))
(not (android-makefile-exists-p default-directory)))
(setq default-directory
(substring default-directory 0
(string-match "[^/]+/$" default-directory))))
(when (not (android-makefile-exists-p default-directory))
(error "Not in a valid android tree"))
(if (string= default-directory topdir)
(list "Makefile" t)
;; Remove the root dir at the start of the filename
(setq default-directory (substring default-directory (length topdir) nil))
(setq file (concat default-directory "Android.mk"))
(list file nil))))
;; This filter is registered as a `compilation-filter-hook' and is
;; called when new data has been inserted in the compile buffer. Don't
;; assume that only one line has been inserted, typically more than
;; one has changed since the last call due to stdout buffering.
;;
;; We store in a buffer local variable `android-compile-context' a
;; list with 2 elements, the process and point position at the end of
;; the last invocation. The process is used to detect a new
;; compilation. The point position is used to limit our search.
;;
;; On entry (point) is at the end of the last block inserted.
(defun android-compile-filter ()
"Filter to discard unwanted lines from the compilation buffer.
This filter is registered as a `compilation-filter-hook' and is
called when new data has been inserted in the compile buffer.
Has effect only if `android-compilation-no-buildenv-warning' is
not nil."
;; Currently we are looking only for compilation warnings from the
;; build env. Move this test lower, near the while loop if we
;; support more than one category of regexp.
(when android-compilation-no-buildenv-warning
;; Check if android-compile-context does not exist or if the
;; process has changed: new compilation.
(let ((proc (get-buffer-process (current-buffer))))
(unless (and (local-variable-p 'android-compile-context)
(eq proc (cadr android-compile-context)))
(setq android-compile-context (list (point-min) proc))
(make-local-variable 'android-compile-context)))
(let ((beg (car android-compile-context))
(end (point)))
(save-excursion
(goto-char beg)
;; Need to go back at the beginning of the line before we
;; start the search: because of the buffering, the previous
;; block inserted may have ended in the middle of the
;; expression we are trying to match. As result we missed it
;; last time and we would miss it again if we started just
;; where we left of. By processing the line from the start we
;; are catching that case.
(forward-line 0)
(while (search-forward-regexp android-compile-ignore-re end t)
;; Nuke the line
(let ((bol (point-at-bol)))
(forward-line 1)
(delete-region bol (point)))))
;; Remember the new end for next time around.
(setcar android-compile-context (point)))))
(defun android-compile ()
"Elisp equivalent of mm shell function.
Walk up the path until a makefile is found and build it.
You need to have a proper buildspec.mk in your top dir.
Use `android-compilation-jobs' to control the number of jobs used
in a compilation."
(interactive)
(if (android-project-p)
(let* ((topdir (android-find-build-tree-root))
(makefile (android-find-makefile topdir))
(options
(concat " -j " (number-to-string android-compilation-jobs))))
(unless (file-exists-p (concat topdir "buildspec.mk"))
(error "buildspec.mk missing in %s." topdir))
;; Add-hook do not re-add if already present. The compile
;; filter hooks run after the comint cleanup (^M).
(add-hook 'compilation-filter-hook 'android-compile-filter)
(set (make-local-variable 'compile-command)
(if (cadr makefile)
;; The root Makefile is not invoked using ONE_SHOT_MAKEFILE.
(concat "make -C " topdir options) ; Build the whole image.
(concat "ONE_SHOT_MAKEFILE=" (car makefile)
" make -C " topdir options " files ")))
(if (interactive-p)
(call-interactively 'compile)))))
(provide 'android-compile)
;;; android-compile.el ends here

122
ide/emacs/android-host.el
View File

@@ -1,122 +0,0 @@
;;; android-host.el --- Module to use host binaries from an Android dev tree.
;;
;; Copyright (C) 2009 The Android Open Source Project
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;; http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.
;;; Commentary:
;;
;; This module defines interactive functions to send the most common
;; commands to a device.
;;
;; Currently only one device is supported.
;;
;; In your .emacs load this file (e.g (require 'android-host)) then
;; you can either create new shortcuts e.g:
;;
;; (global-set-key [f8] 'android-adb-sync)
;;
;; or rely on autocompletion M-x and-sync will expand to
;; M-x android-adb-sync
;;
;; By default the following key bindings are active:
;; C-x a a android-adb-root
;; C-x a r android-adb-remount
;; C-x a s android-adb-sync
;; C-x a b android-adb-shell-reboot-bootloader
;; C-x a f android-fastboot-flashall
;;
;; android-fastboot-flashall is still work in progress, check the
;; associated buffer (*Android Output*) for errors when you use it.
;;; Code:
(require 'android-common)
(defvar android-host-command-map (make-sparse-keymap))
(defun android-host-key-prefix-set (var val)
"Bind the keys shortcuts to the functions.i"
;; TODO: This should go in a minor mode keymap instead of
;; messing with the global one.
(define-key global-map (read-kbd-macro val) android-host-command-map)
(custom-set-default var val))
(let ((map android-host-command-map))
(define-key map (kbd "a") 'android-adb-root)
(define-key map (kbd "r") 'android-adb-remount)
(define-key map (kbd "s") 'android-adb-sync)
(define-key map (kbd "b") 'android-adb-shell-reboot-bootloader)
(define-key map (kbd "f") 'android-fastboot-flashall))
(defcustom android-host-key-prefix "C-x a"
"Prefix keystrokes for Android commands."
:group 'android
:type 'string
:set 'android-host-key-prefix-set)
(defun android-adb-remount ()
"Execute 'adb remount'."
(interactive)
(android-adb-command "remount"))
(defun android-adb-root ()
"Execute 'adb root'."
(interactive)
(android-adb-command "root"))
(defun android-adb-shell-reboot-bootloader ()
"Execute 'adb shell reboot bootloader'."
(interactive)
(android-adb-shell-command "reboot bootloader"))
(defun android-adb-sync ()
"Execute 'adb sync'."
(interactive)
;; Always force root and remount, this way sync always works even on
;; a device that has just rebooted or that runs a userdebug build.
(android-adb-root)
(android-adb-remount)
(android-adb-command "sync" 'p))
(defun android-fastboot-sentinel (process event)
"Called when the fastboot process is done."
;; TODO: Should barf if the last lines are not:
;; OKAY
;; rebooting...
(princ
(format "Process: %s had the event `%s'" process event)))
(defun android-fastboot-flashall (arg)
"Execute 'fastboot -p <product> flashall'.
With no ARG, don't wipe the user data.
With ARG, wipe the user data."
(interactive "P")
(when (get-buffer android-output-buffer-name)
(with-current-buffer android-output-buffer-name
(erase-buffer)))
(let ((proc
(if arg
(start-process-shell-command
"fastboot"
android-output-buffer-name
(concat (android-fastboot) " flashall -w"))
(start-process-shell-command
"fastboot" android-output-buffer-name
(concat (android-fastboot) " flashall")))))
(set-process-sentinel proc 'android-fastboot-sentinel)))
(provide 'android-host)
;;; android-host.el ends here