70 |
71 |
--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_launcher_foreground.xml:
--------------------------------------------------------------------------------
1 |
2 |
8 |
13 |
14 |
17 |
18 |
19 |
22 |
23 |
24 |
25 |
31 |
34 |
37 |
38 |
39 |
40 |
46 |
--------------------------------------------------------------------------------
/app/src/main/java/com/maticcm/openwebuiclient/IpInputActivity.kt:
--------------------------------------------------------------------------------
1 | package com.maticcm.openwebuiclient
2 |
3 | import android.content.Intent
4 | import android.os.Bundle
5 | import android.view.animation.AnimationUtils
6 | import android.widget.Toast
7 | import androidx.appcompat.app.AppCompatActivity
8 | import androidx.core.view.isVisible
9 | import com.maticcm.openwebuiclient.databinding.ActivityIpInputBinding
10 |
11 | class IpInputActivity : AppCompatActivity() {
12 | private lateinit var binding: ActivityIpInputBinding
13 |
14 | override fun onCreate(savedInstanceState: Bundle?) {
15 | super.onCreate(savedInstanceState)
16 |
17 | // Check for saved URL before inflating layout
18 | val savedUrl = getSharedPreferences("AppPrefs", MODE_PRIVATE)
19 | .getString("SAVED_URL", null)
20 | val setupComplete = getSharedPreferences("OpenWebUIClient", MODE_PRIVATE)
21 | .getBoolean("setup_complete", false)
22 |
23 | if (savedUrl != null && setupComplete) {
24 | startWebViewActivity(savedUrl)
25 | return
26 | }
27 |
28 | binding = ActivityIpInputBinding.inflate(layoutInflater)
29 | setContentView(binding.root)
30 |
31 | setupViews()
32 | }
33 |
34 | private fun setupViews() {
35 | // Show all views immediately
36 | binding.titleTextView.alpha = 1f
37 | binding.ipInputLayout.alpha = 1f
38 | binding.submitButton.alpha = 1f
39 |
40 | binding.submitButton.setOnClickListener {
41 | val url = binding.ipInputEditText.text.toString().trim()
42 |
43 | if (url.isEmpty()) {
44 | showError("Please enter a URL")
45 | return@setOnClickListener
46 | }
47 |
48 | // Save the URL and mark setup as complete
49 | getSharedPreferences("AppPrefs", MODE_PRIVATE)
50 | .edit()
51 | .putString("SAVED_URL", url)
52 | .apply()
53 |
54 | getSharedPreferences("OpenWebUIClient", MODE_PRIVATE)
55 | .edit()
56 | .putBoolean("setup_complete", true)
57 | .apply()
58 |
59 | startWebViewActivity(url)
60 | }
61 | }
62 |
63 | private fun startWebViewActivity(url: String) {
64 | startActivity(Intent(this, WebViewActivity::class.java).apply {
65 | putExtra("URL", url)
66 | })
67 | finish()
68 | }
69 |
70 | private fun showError(message: String) {
71 | binding.errorTextView.text = message
72 | binding.errorTextView.isVisible = true
73 | }
74 |
75 | override fun onBackPressed() {
76 | // Go back to welcome screen
77 | startActivity(Intent(this, WelcomeActivity::class.java))
78 | finish()
79 | overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out)
80 | }
81 | }
--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
1 | @rem
2 | @rem Copyright 2015 the original author or authors.
3 | @rem
4 | @rem Licensed under the Apache License, Version 2.0 (the "License");
5 | @rem you may not use this file except in compliance with the License.
6 | @rem You may obtain a copy of the License at
7 | @rem
8 | @rem https://www.apache.org/licenses/LICENSE-2.0
9 | @rem
10 | @rem Unless required by applicable law or agreed to in writing, software
11 | @rem distributed under the License is distributed on an "AS IS" BASIS,
12 | @rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 | @rem See the License for the specific language governing permissions and
14 | @rem limitations under the License.
15 | @rem
16 |
17 | @if "%DEBUG%" == "" @echo off
18 | @rem ##########################################################################
19 | @rem
20 | @rem Gradle startup script for Windows
21 | @rem
22 | @rem ##########################################################################
23 |
24 | @rem Set local scope for the variables with windows NT shell
25 | if "%OS%"=="Windows_NT" setlocal
26 |
27 | set DIRNAME=%~dp0
28 | if "%DIRNAME%" == "" set DIRNAME=.
29 | set APP_BASE_NAME=%~n0
30 | set APP_HOME=%DIRNAME%
31 |
32 | @rem Resolve any "." and ".." in APP_HOME to make it shorter.
33 | for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
34 |
35 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
36 | set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
37 |
38 | @rem Find java.exe
39 | if defined JAVA_HOME goto findJavaFromJavaHome
40 |
41 | set JAVA_EXE=java.exe
42 | %JAVA_EXE% -version >NUL 2>&1
43 | if "%ERRORLEVEL%" == "0" goto execute
44 |
45 | echo.
46 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
47 | echo.
48 | echo Please set the JAVA_HOME variable in your environment to match the
49 | echo location of your Java installation.
50 |
51 | goto fail
52 |
53 | :findJavaFromJavaHome
54 | set JAVA_HOME=%JAVA_HOME:"=%
55 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
56 |
57 | if exist "%JAVA_EXE%" goto execute
58 |
59 | echo.
60 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
61 | echo.
62 | echo Please set the JAVA_HOME variable in your environment to match the
63 | echo location of your Java installation.
64 |
65 | goto fail
66 |
67 | :execute
68 | @rem Setup the command line
69 |
70 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
71 |
72 |
73 | @rem Execute Gradle
74 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
75 |
76 | :end
77 | @rem End local scope for the variables with windows NT shell
78 | if "%ERRORLEVEL%"=="0" goto mainEnd
79 |
80 | :fail
81 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
82 | rem the _cmd.exe /c_ return code!
83 | if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
84 | exit /b 1
85 |
86 | :mainEnd
87 | if "%OS%"=="Windows_NT" endlocal
88 |
89 | :omega
90 |
--------------------------------------------------------------------------------
/app/src/main/java/com/maticcm/openwebuiclient/WelcomeActivity.kt:
--------------------------------------------------------------------------------
1 | package com.maticcm.openwebuiclient
2 |
3 | import android.content.Intent
4 | import android.content.SharedPreferences
5 | import android.net.Uri
6 | import android.os.Bundle
7 | import android.view.View
8 | import android.view.animation.AnimationUtils
9 | import androidx.appcompat.app.AppCompatActivity
10 | import com.maticcm.openwebuiclient.databinding.ActivityWelcomeBinding
11 |
12 | class WelcomeActivity : AppCompatActivity() {
13 | private lateinit var binding: ActivityWelcomeBinding
14 | private lateinit var sharedPreferences: SharedPreferences
15 |
16 | override fun onCreate(savedInstanceState: Bundle?) {
17 | super.onCreate(savedInstanceState)
18 | binding = ActivityWelcomeBinding.inflate(layoutInflater)
19 | setContentView(binding.root)
20 |
21 | sharedPreferences = getSharedPreferences("OpenWebUIClient", MODE_PRIVATE)
22 |
23 | // Check if setup is complete (both welcome seen AND URL saved)
24 | val savedUrl = getSharedPreferences("AppPrefs", MODE_PRIVATE)
25 | .getString("SAVED_URL", null)
26 | val setupComplete = sharedPreferences.getBoolean("setup_complete", false)
27 |
28 | if (setupComplete && savedUrl != null) {
29 | startIpInputActivity()
30 | return
31 | }
32 |
33 | // Set up animations
34 | setupAnimations()
35 |
36 | binding.getStartedButton.setOnClickListener {
37 | startIpInputActivity()
38 | }
39 |
40 | binding.donateTextView.setOnClickListener {
41 | val intent = Intent(Intent.ACTION_VIEW, Uri.parse("https://ko-fi.com/maticcukimikeln"))
42 | startActivity(intent)
43 | }
44 | }
45 |
46 | private fun setupAnimations() {
47 | // Fade in the logo
48 | binding.logoImageView.visibility = View.INVISIBLE
49 | binding.logoImageView.post {
50 | binding.logoImageView.startAnimation(
51 | AnimationUtils.loadAnimation(this, android.R.anim.fade_in)
52 | )
53 | binding.logoImageView.visibility = View.VISIBLE
54 | }
55 |
56 | // Slide up the title and description
57 | binding.titleTextView.startAnimation(
58 | AnimationUtils.loadAnimation(this, android.R.anim.slide_in_left)
59 | )
60 | binding.descriptionTextView.startAnimation(
61 | AnimationUtils.loadAnimation(this, android.R.anim.slide_in_left)
62 | )
63 |
64 | // Fade in the button with a delay
65 | binding.getStartedButton.alpha = 0f
66 | binding.getStartedButton.animate()
67 | .alpha(1f)
68 | .setStartDelay(1000)
69 | .setDuration(500)
70 | .start()
71 | }
72 |
73 | private fun startIpInputActivity() {
74 | val intent = Intent(this, IpInputActivity::class.java)
75 | startActivity(intent)
76 | finish()
77 | overridePendingTransition(android.R.anim.fade_in, android.R.anim.fade_out)
78 | }
79 | }
--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_welcome.xml:
--------------------------------------------------------------------------------
1 |
2 |
7 |
8 |
19 |
20 |
32 |
33 |
47 |
48 |
61 |
62 |
70 |
71 |
--------------------------------------------------------------------------------
/app/src/main/res/layout/activity_ip_input.xml:
--------------------------------------------------------------------------------
1 |
2 |
8 |
9 |
20 |
21 |
33 |
34 |
41 |
42 |
43 |
44 |
54 |
55 |
63 |
64 |
74 |
75 |
--------------------------------------------------------------------------------
/app/src/main/AndroidManifest.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
5 |
6 |
7 |
9 |
10 |
11 |
12 |
13 |
14 |
25 |
30 |
33 |
34 |
39 |
40 |
41 |
42 |
43 |
44 |
49 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
--------------------------------------------------------------------------------
/.idea/codeStyles/Project.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 | xmlns:android
18 |
19 | ^$
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 | xmlns:.*
29 |
30 | ^$
31 |
32 |
33 | BY_NAME
34 |
35 |
36 |
37 |
38 |
39 |
40 | .*:id
41 |
42 | http://schemas.android.com/apk/res/android
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 | .*:name
52 |
53 | http://schemas.android.com/apk/res/android
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 | name
63 |
64 | ^$
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 | style
74 |
75 | ^$
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 | .*
85 |
86 | ^$
87 |
88 |
89 | BY_NAME
90 |
91 |
92 |
93 |
94 |
95 |
96 | .*
97 |
98 | http://schemas.android.com/apk/res/android
99 |
100 |
101 | ANDROID_ATTRIBUTE_ORDER
102 |
103 |
104 |
105 |
106 |
107 |
108 | .*
109 |
110 | .*
111 |
112 |
113 | BY_NAME
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
--------------------------------------------------------------------------------
/app/src/main/res/drawable/ic_launcher_background.xml:
--------------------------------------------------------------------------------
1 |
2 |
8 |
10 |
12 |
14 |
16 |
18 |
20 |
22 |
24 |
26 |
28 |
30 |
32 |
34 |
36 |
38 |
40 |
42 |
44 |
46 |
48 |
50 |
52 |
54 |
56 |
58 |
60 |
62 |
64 |
66 |
68 |
70 |
72 |
74 |
75 |
--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env sh
2 |
3 | #
4 | # Copyright 2015 the original author or authors.
5 | #
6 | # Licensed under the Apache License, Version 2.0 (the "License");
7 | # you may not use this file except in compliance with the License.
8 | # You may obtain a copy of the License at
9 | #
10 | # https://www.apache.org/licenses/LICENSE-2.0
11 | #
12 | # Unless required by applicable law or agreed to in writing, software
13 | # distributed under the License is distributed on an "AS IS" BASIS,
14 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 | # See the License for the specific language governing permissions and
16 | # limitations under the License.
17 | #
18 |
19 | ##############################################################################
20 | ##
21 | ## Gradle start up script for UN*X
22 | ##
23 | ##############################################################################
24 |
25 | # Attempt to set APP_HOME
26 | # Resolve links: $0 may be a link
27 | PRG="$0"
28 | # Need this for relative symlinks.
29 | while [ -h "$PRG" ] ; do
30 | ls=`ls -ld "$PRG"`
31 | link=`expr "$ls" : '.*-> \(.*\)$'`
32 | if expr "$link" : '/.*' > /dev/null; then
33 | PRG="$link"
34 | else
35 | PRG=`dirname "$PRG"`"/$link"
36 | fi
37 | done
38 | SAVED="`pwd`"
39 | cd "`dirname \"$PRG\"`/" >/dev/null
40 | APP_HOME="`pwd -P`"
41 | cd "$SAVED" >/dev/null
42 |
43 | APP_NAME="Gradle"
44 | APP_BASE_NAME=`basename "$0"`
45 |
46 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
47 | DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
48 |
49 | # Use the maximum available, or set MAX_FD != -1 to use that value.
50 | MAX_FD="maximum"
51 |
52 | warn () {
53 | echo "$*"
54 | }
55 |
56 | die () {
57 | echo
58 | echo "$*"
59 | echo
60 | exit 1
61 | }
62 |
63 | # OS specific support (must be 'true' or 'false').
64 | cygwin=false
65 | msys=false
66 | darwin=false
67 | nonstop=false
68 | case "`uname`" in
69 | CYGWIN* )
70 | cygwin=true
71 | ;;
72 | Darwin* )
73 | darwin=true
74 | ;;
75 | MINGW* )
76 | msys=true
77 | ;;
78 | NONSTOP* )
79 | nonstop=true
80 | ;;
81 | esac
82 |
83 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
84 |
85 |
86 | # Determine the Java command to use to start the JVM.
87 | if [ -n "$JAVA_HOME" ] ; then
88 | if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
89 | # IBM's JDK on AIX uses strange locations for the executables
90 | JAVACMD="$JAVA_HOME/jre/sh/java"
91 | else
92 | JAVACMD="$JAVA_HOME/bin/java"
93 | fi
94 | if [ ! -x "$JAVACMD" ] ; then
95 | die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
96 |
97 | Please set the JAVA_HOME variable in your environment to match the
98 | location of your Java installation."
99 | fi
100 | else
101 | JAVACMD="java"
102 | which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
103 |
104 | Please set the JAVA_HOME variable in your environment to match the
105 | location of your Java installation."
106 | fi
107 |
108 | # Increase the maximum file descriptors if we can.
109 | if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
110 | MAX_FD_LIMIT=`ulimit -H -n`
111 | if [ $? -eq 0 ] ; then
112 | if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
113 | MAX_FD="$MAX_FD_LIMIT"
114 | fi
115 | ulimit -n $MAX_FD
116 | if [ $? -ne 0 ] ; then
117 | warn "Could not set maximum file descriptor limit: $MAX_FD"
118 | fi
119 | else
120 | warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
121 | fi
122 | fi
123 |
124 | # For Darwin, add options to specify how the application appears in the dock
125 | if $darwin; then
126 | GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
127 | fi
128 |
129 | # For Cygwin or MSYS, switch paths to Windows format before running java
130 | if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
131 | APP_HOME=`cygpath --path --mixed "$APP_HOME"`
132 | CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
133 |
134 | JAVACMD=`cygpath --unix "$JAVACMD"`
135 |
136 | # We build the pattern for arguments to be converted via cygpath
137 | ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
138 | SEP=""
139 | for dir in $ROOTDIRSRAW ; do
140 | ROOTDIRS="$ROOTDIRS$SEP$dir"
141 | SEP="|"
142 | done
143 | OURCYGPATTERN="(^($ROOTDIRS))"
144 | # Add a user-defined pattern to the cygpath arguments
145 | if [ "$GRADLE_CYGPATTERN" != "" ] ; then
146 | OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
147 | fi
148 | # Now convert the arguments - kludge to limit ourselves to /bin/sh
149 | i=0
150 | for arg in "$@" ; do
151 | CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
152 | CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option
153 |
154 | if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition
155 | eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
156 | else
157 | eval `echo args$i`="\"$arg\""
158 | fi
159 | i=`expr $i + 1`
160 | done
161 | case $i in
162 | 0) set -- ;;
163 | 1) set -- "$args0" ;;
164 | 2) set -- "$args0" "$args1" ;;
165 | 3) set -- "$args0" "$args1" "$args2" ;;
166 | 4) set -- "$args0" "$args1" "$args2" "$args3" ;;
167 | 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
168 | 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
169 | 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
170 | 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
171 | 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
172 | esac
173 | fi
174 |
175 | # Escape application args
176 | save () {
177 | for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
178 | echo " "
179 | }
180 | APP_ARGS=`save "$@"`
181 |
182 | # Collect all arguments for the java command, following the shell quoting and substitution rules
183 | eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
184 |
185 | exec "$JAVACMD" "$@"
186 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 |
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------
/app/src/main/java/com/maticcm/openwebuiclient/WebViewActivity.kt:
--------------------------------------------------------------------------------
1 | package com.maticcm.openwebuiclient
2 |
3 | import android.Manifest
4 | import android.app.DownloadManager
5 | import android.content.BroadcastReceiver
6 | import android.content.Context
7 | import android.content.Intent
8 | import android.content.IntentFilter
9 | import android.content.pm.PackageManager
10 | import android.net.Uri
11 | import android.os.Bundle
12 | import android.os.Environment
13 | import android.provider.MediaStore
14 | import android.util.Log
15 | import android.view.GestureDetector
16 | import android.view.MotionEvent
17 | import android.view.ScaleGestureDetector
18 | import android.view.View
19 | import android.webkit.DownloadListener
20 | import android.webkit.URLUtil
21 | import android.webkit.WebView
22 | import android.webkit.WebViewClient
23 | import android.webkit.WebSettings
24 | import android.webkit.WebChromeClient
25 | import android.webkit.WebResourceError
26 | import android.webkit.WebResourceRequest
27 | import android.webkit.ValueCallback
28 | import android.webkit.WebChromeClient.FileChooserParams
29 | import android.os.Handler
30 | import android.os.Looper
31 | import androidx.activity.OnBackPressedCallback
32 | import androidx.activity.result.contract.ActivityResultContracts
33 | import androidx.activity.result.ActivityResultLauncher
34 | import androidx.appcompat.app.AlertDialog
35 | import androidx.appcompat.app.AppCompatActivity
36 | import androidx.core.app.ActivityCompat
37 | import androidx.core.content.ContextCompat
38 | import androidx.core.view.isVisible
39 | import com.google.android.material.textfield.TextInputEditText
40 | import com.google.android.material.textfield.TextInputLayout
41 | import com.maticcm.openwebuiclient.databinding.ActivityWebviewBinding
42 | import com.maticcm.openwebuiclient.databinding.DialogSettingsBinding
43 | import com.maticcm.openwebuiclient.databinding.LongPressIndicatorBinding
44 | import org.json.JSONObject
45 | import java.io.File
46 | import java.text.SimpleDateFormat
47 | import java.util.Date
48 | import java.util.Locale
49 | import androidx.core.content.FileProvider
50 | import java.util.regex.Pattern
51 | import android.webkit.JavascriptInterface
52 | import android.webkit.PermissionRequest
53 |
54 | class WebViewActivity : AppCompatActivity() {
55 | private lateinit var binding: ActivityWebviewBinding
56 | private lateinit var baseUrl: String
57 | private var isWebViewReady = false
58 | private var filePathCallback: ValueCallback>? = null
59 | private var cameraImageUri: Uri? = null
60 | private val timeoutHandler = Handler(Looper.getMainLooper())
61 | private val CONNECTION_TIMEO = 30000L // 30 seconds timeout
62 | private val timeoutRunnable = Runnable {
63 | if (!isWebViewReady) {
64 | Log.e("WebViewActivity", "Connection timeout")
65 | binding.progressBar.isVisible = false
66 | showConnectionError()
67 | }
68 | }
69 |
70 | // Gesture detection
71 | private var longPressStartTime = 0L
72 | private var isLongPressing = false
73 | private val LONG_PRESS_DURATION = 3000L // 3 seconds
74 | private val REQUIRED_FINGERS = 4
75 | private var longPressIndicator: AlertDialog? = null
76 | private var progressUpdateRunnable: Runnable? = null
77 | private var activePointers = mutableSetOf()
78 |
79 | // Validation patterns
80 | private val YOUTUBE_ID_PATTERN = Pattern.compile("^[a-zA-Z0-9_-]{11}$")
81 | private val MODEL_NAME_PATTERN = Pattern.compile("^[a-zA-Z0-9_-]+$")
82 | private val TOOL_ID_PATTERN = Pattern.compile("^[a-zA-Z0-9_-]+$")
83 | private val QUERY_PATTERN = Pattern.compile("^[\\w\\s\\p{Punct}]+$")
84 | private val HOST_PATTERN = Pattern.compile("^[a-zA-Z0-9.-]+$")
85 |
86 | // URL validation
87 | private val URL_PATTERN = Pattern.compile(
88 | "^https?://" + // http:// or https://
89 | "([a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+" + // domain
90 | "[a-zA-Z]{2,}" + // TLD
91 | "(/[a-zA-Z0-9-._~:/?#\\[\\]@!\\$&'\\(\\)\\*\\+,;=]*)?$" // path and query
92 | )
93 |
94 | // Permission handling
95 | private val CAMERA_PERMISSION_REQUEST = 100
96 | private val MICROPHONE_PERMISSION_REQUEST = 101
97 | private var pendingCameraCapture = false
98 | private var pendingMicrophoneAccess = false
99 |
100 | private val requestPermissionLauncher = registerForActivityResult(
101 | ActivityResultContracts.RequestPermission()
102 | ) { isGranted ->
103 | if (isGranted) {
104 | Log.d("WebViewActivity", "Permission granted")
105 | if (pendingCameraCapture) {
106 | pendingCameraCapture = false
107 | launchCamera()
108 | }
109 | if (pendingMicrophoneAccess) {
110 | pendingMicrophoneAccess = false
111 | // Inject JavaScript to notify the web page that permission was granted
112 | injectMicrophonePermissionGranted()
113 | }
114 | } else {
115 | Log.e("WebViewActivity", "Permission denied")
116 | if (pendingCameraCapture) {
117 | filePathCallback?.onReceiveValue(null)
118 | filePathCallback = null
119 | }
120 | if (pendingMicrophoneAccess) {
121 | injectMicrophonePermissionDenied()
122 | }
123 | }
124 | }
125 |
126 | private val fileChooserLauncher = registerForActivityResult(ActivityResultContracts.GetMultipleContents()) { uris ->
127 | if (uris.isNotEmpty()) {
128 | filePathCallback?.onReceiveValue(uris.toTypedArray())
129 | } else {
130 | filePathCallback?.onReceiveValue(null)
131 | }
132 | filePathCallback = null
133 | }
134 |
135 | private val singleFileChooserLauncher = registerForActivityResult(ActivityResultContracts.GetContent()) { uri ->
136 | uri?.let {
137 | filePathCallback?.onReceiveValue(arrayOf(it))
138 | } ?: run {
139 | filePathCallback?.onReceiveValue(null)
140 | }
141 | filePathCallback = null
142 | }
143 |
144 | private val cameraLauncher = registerForActivityResult(ActivityResultContracts.TakePicture()) { success ->
145 | if (success && cameraImageUri != null) {
146 | filePathCallback?.onReceiveValue(arrayOf(cameraImageUri!!))
147 | } else {
148 | filePathCallback?.onReceiveValue(null)
149 | }
150 | filePathCallback = null
151 | cameraImageUri = null
152 | }
153 |
154 | private fun createImageFile(): File {
155 | try {
156 | val timeStamp = SimpleDateFormat("yyyyMMdd_HHmmss", Locale.getDefault()).format(Date())
157 | val imageFileName = "JPEG_" + timeStamp + "_"
158 | val storageDir = getExternalFilesDir(Environment.DIRECTORY_PICTURES)
159 | if (storageDir == null) {
160 | Log.e("WebViewActivity", "Failed to get external files directory")
161 | throw IllegalStateException("Failed to get external files directory")
162 | }
163 | return File.createTempFile(
164 | imageFileName,
165 | ".jpg",
166 | storageDir
167 | )
168 | } catch (e: Exception) {
169 | Log.e("WebViewActivity", "Error creating image file", e)
170 | throw e
171 | }
172 | }
173 |
174 | override fun onCreate(savedInstanceState: Bundle?) {
175 | super.onCreate(savedInstanceState)
176 |
177 | // Initialize WebView settings globally for better performance
178 | WebView.enableSlowWholeDocumentDraw()
179 |
180 | binding = ActivityWebviewBinding.inflate(layoutInflater)
181 | setContentView(binding.root)
182 |
183 | // Request microphone permission immediately
184 | if (!checkMicrophonePermission()) {
185 | requestMicrophonePermission()
186 | }
187 |
188 | // Get the saved URL
189 | baseUrl = getSharedPreferences("AppPrefs", MODE_PRIVATE)
190 | .getString("SAVED_URL", null) ?: return
191 |
192 | setupWebView()
193 | handleIntent(intent)
194 |
195 | // Handle back button press
196 | onBackPressedDispatcher.addCallback(this, object : OnBackPressedCallback(true) {
197 | override fun handleOnBackPressed() {
198 | if (binding.webView.canGoBack()) {
199 | binding.webView.goBack()
200 | } else {
201 | isEnabled = false
202 | onBackPressedDispatcher.onBackPressed()
203 | }
204 | }
205 | })
206 | }
207 |
208 | private fun setupWebView() {
209 | binding.webView.settings.apply {
210 | javaScriptEnabled = true
211 | domStorageEnabled = true
212 | databaseEnabled = true
213 | setSupportMultipleWindows(true)
214 | allowContentAccess = true
215 | allowFileAccess = true
216 | loadWithOverviewMode = true
217 | useWideViewPort = true
218 | setSupportZoom(true)
219 | builtInZoomControls = true
220 | displayZoomControls = false
221 | cacheMode = WebSettings.LOAD_DEFAULT
222 | // Note: These settings are deprecated but still needed for some functionality
223 | @Suppress("DEPRECATION")
224 | allowFileAccessFromFileURLs = true
225 | @Suppress("DEPRECATION")
226 | allowUniversalAccessFromFileURLs = true
227 | mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
228 | @Suppress("DEPRECATION")
229 | allowContentAccess = true
230 | @Suppress("DEPRECATION")
231 | allowFileAccess = true
232 | @Suppress("DEPRECATION")
233 | setAllowFileAccess(true)
234 | @Suppress("DEPRECATION")
235 | setAllowContentAccess(true)
236 | // Enable media permissions
237 | @Suppress("DEPRECATION")
238 | mediaPlaybackRequiresUserGesture = false
239 | }
240 |
241 | // Enable mixed content for Android 5.0 and above
242 | if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
243 | binding.webView.settings.mixedContentMode = WebSettings.MIXED_CONTENT_ALWAYS_ALLOW
244 | }
245 |
246 | // Add JavaScript interface for microphone permission
247 | binding.webView.addJavascriptInterface(object {
248 | @JavascriptInterface
249 | fun requestMicrophonePermission() {
250 | runOnUiThread {
251 | Log.d("WebViewActivity", "Microphone permission requested from JavaScript")
252 | if (checkMicrophonePermission()) {
253 | Log.d("WebViewActivity", "Microphone permission already granted")
254 | injectMicrophonePermissionGranted()
255 | } else {
256 | Log.d("WebViewActivity", "Requesting microphone permission")
257 | pendingMicrophoneAccess = true
258 | requestMicrophonePermission()
259 | }
260 | }
261 | }
262 |
263 | @JavascriptInterface
264 | fun log(message: String) {
265 | Log.d("WebViewActivity", "JavaScript: $message")
266 | }
267 |
268 | @JavascriptInterface
269 | fun openLink(url: String) {
270 | runOnUiThread {
271 | Log.d("WebViewActivity", "Opening link: $url")
272 | try {
273 | val intent = Intent(Intent.ACTION_VIEW, Uri.parse(url))
274 | startActivity(intent)
275 | } catch (e: Exception) {
276 | Log.e("WebViewActivity", "Error opening link: $url", e)
277 | }
278 | }
279 | }
280 | }, "Android")
281 |
282 | binding.webView.setLayerType(WebView.LAYER_TYPE_HARDWARE, null)
283 |
284 | // Set up touch event handling
285 | binding.webView.setOnTouchListener { _, event ->
286 | @Suppress("DEPRECATION")
287 | handleTouchEvent(event)
288 | false // Return false to allow WebView to handle the event as well
289 | }
290 |
291 | // Set up WebChromeClient with media permissions
292 | binding.webView.webChromeClient = object : WebChromeClient() {
293 | override fun onPermissionRequest(request: PermissionRequest) {
294 | Log.d("WebViewActivity", "Permission request received: ${request.resources.joinToString()}")
295 | // Always grant microphone permission if we have it
296 | if (request.resources.contains(PermissionRequest.RESOURCE_AUDIO_CAPTURE)) {
297 | if (checkMicrophonePermission()) {
298 | Log.d("WebViewActivity", "Granting microphone permission")
299 | // Inject JavaScript to notify the web page that permission was granted
300 | injectMicrophonePermissionGranted()
301 | request.grant(arrayOf(PermissionRequest.RESOURCE_AUDIO_CAPTURE))
302 | } else {
303 | Log.d("WebViewActivity", "Requesting microphone permission")
304 | pendingMicrophoneAccess = true
305 | requestMicrophonePermission()
306 | }
307 | } else {
308 | // Grant all other permissions
309 | Log.d("WebViewActivity", "Granting other permissions: ${request.resources.joinToString()}")
310 | request.grant(request.resources)
311 | }
312 | }
313 |
314 | @Deprecated("Deprecated in Java", ReplaceWith("onShowFileChooser(webView, filePathCallback, fileChooserParams)"))
315 | override fun onShowFileChooser(
316 | webView: WebView?,
317 | filePathCallback: ValueCallback>?,
318 | fileChooserParams: FileChooserParams?
319 | ): Boolean {
320 | try {
321 | Log.d("WebViewActivity", "onShowFileChooser called")
322 | this@WebViewActivity.filePathCallback?.onReceiveValue(null)
323 | this@WebViewActivity.filePathCallback = filePathCallback
324 |
325 | val captureEnabled = fileChooserParams?.isCaptureEnabled ?: false
326 | val multiple = fileChooserParams?.mode == FileChooserParams.MODE_OPEN_MULTIPLE
327 |
328 | Log.d("WebViewActivity", "Capture enabled: $captureEnabled, Multiple: $multiple")
329 |
330 | if (captureEnabled) {
331 | if (checkCameraPermission()) {
332 | launchCamera()
333 | } else {
334 | pendingCameraCapture = true
335 | requestCameraPermission()
336 | }
337 | } else {
338 | // Handle file selection
339 | if (multiple) {
340 | fileChooserLauncher.launch("*/*")
341 | } else {
342 | singleFileChooserLauncher.launch("*/*")
343 | }
344 | }
345 | return true
346 | } catch (e: Exception) {
347 | Log.e("WebViewActivity", "Error in onShowFileChooser", e)
348 | filePathCallback?.onReceiveValue(null)
349 | this@WebViewActivity.filePathCallback = null
350 | return false
351 | }
352 | }
353 | }
354 |
355 | // Set up WebViewClient
356 | binding.webView.webViewClient = object : WebViewClient() {
357 | override fun onReceivedError(
358 | view: WebView?,
359 | request: WebResourceRequest?,
360 | error: WebResourceError?
361 | ) {
362 | super.onReceivedError(view, request, error)
363 | timeoutHandler.removeCallbacks(timeoutRunnable)
364 | Log.e("WebViewActivity", "WebView error: ${error?.description}")
365 | showConnectionError()
366 | }
367 |
368 | override fun onPageFinished(view: WebView?, url: String?) {
369 | timeoutHandler.removeCallbacks(timeoutRunnable)
370 | binding.progressBar.isVisible = false
371 | binding.webView.alpha = 1f
372 | isWebViewReady = true
373 | Log.d("WebViewActivity", "WebView loaded: $url")
374 | injectImageHandlingScript()
375 | injectLinkHandlingScript()
376 |
377 | // Inject JavaScript to handle microphone access
378 | val microphoneScript = """
379 | window.Android.log('Page loaded, setting up microphone access');
380 |
381 | // Create a global function to handle microphone access
382 | window.handleMicrophoneAccess = function() {
383 | window.Android.log('handleMicrophoneAccess called');
384 | return new Promise(function(resolve, reject) {
385 | window.Android.log('Requesting microphone permission');
386 | window.Android.requestMicrophonePermission();
387 | resolve();
388 | });
389 | };
390 |
391 | // Override getUserMedia if available
392 | if (window.navigator.mediaDevices) {
393 | window.Android.log('Media devices available');
394 | const originalGetUserMedia = window.navigator.mediaDevices.getUserMedia;
395 | window.navigator.mediaDevices.getUserMedia = function(constraints) {
396 | window.Android.log('getUserMedia called with constraints: ' + JSON.stringify(constraints));
397 | return window.handleMicrophoneAccess();
398 | };
399 | } else {
400 | window.Android.log('Media devices not available');
401 | }
402 |
403 | // Add error handling
404 | window.addEventListener('error', function(e) {
405 | window.Android.log('JavaScript error: ' + e.message);
406 | });
407 | """.trimIndent()
408 | binding.webView.evaluateJavascript(microphoneScript, null)
409 | }
410 |
411 | override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
412 | if (url?.startsWith(baseUrl) == true) {
413 | return false
414 | }
415 | url?.let {
416 | val intent = Intent(Intent.ACTION_VIEW, Uri.parse(it))
417 | startActivity(intent)
418 | }
419 | return true
420 | }
421 | }
422 |
423 | // Set up download listener
424 | binding.webView.setDownloadListener { url, userAgent, contentDisposition, mimeType, _ ->
425 | try {
426 | val request = DownloadManager.Request(Uri.parse(url))
427 | val filename = URLUtil.guessFileName(url, contentDisposition, mimeType)
428 |
429 | request.apply {
430 | setTitle(filename)
431 | setDescription("Downloading file...")
432 | setNotificationVisibility(DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED)
433 | setDestinationInExternalPublicDir(Environment.DIRECTORY_DOWNLOADS, filename)
434 | addRequestHeader("User-Agent", userAgent)
435 | }
436 |
437 | val downloadManager = getSystemService(Context.DOWNLOAD_SERVICE) as DownloadManager
438 | val downloadId = downloadManager.enqueue(request)
439 | Log.d("WebViewActivity", "Started download: $downloadId for file: $filename")
440 |
441 | // Register broadcast receiver to track download completion
442 | val receiver = object : BroadcastReceiver() {
443 | override fun onReceive(context: Context?, intent: Intent?) {
444 | if (intent?.action == DownloadManager.ACTION_DOWNLOAD_COMPLETE) {
445 | val id = intent.getLongExtra(DownloadManager.EXTRA_DOWNLOAD_ID, -1)
446 | if (id == downloadId) {
447 | val query = DownloadManager.Query().setFilterById(downloadId)
448 | val cursor = downloadManager.query(query)
449 | if (cursor.moveToFirst()) {
450 | val status = cursor.getInt(cursor.getColumnIndexOrThrow(DownloadManager.COLUMN_STATUS))
451 | if (status == DownloadManager.STATUS_SUCCESSFUL) {
452 | Log.d("WebViewActivity", "Download completed successfully: $filename")
453 | } else {
454 | Log.e("WebViewActivity", "Download failed: $filename")
455 | }
456 | }
457 | cursor.close()
458 | unregisterReceiver(this)
459 | }
460 | }
461 | }
462 | }
463 | registerReceiver(receiver, IntentFilter(DownloadManager.ACTION_DOWNLOAD_COMPLETE))
464 | } catch (e: Exception) {
465 | Log.e("WebViewActivity", "Error starting download", e)
466 | }
467 | }
468 |
469 | binding.progressBar.isVisible = true
470 |
471 | // Start timeout timer
472 | timeoutHandler.postDelayed(timeoutRunnable, CONNECTION_TIMEO)
473 |
474 | // Load the URL
475 | binding.webView.loadUrl(baseUrl)
476 | }
477 |
478 | private fun injectCompatibilityScript() {
479 | val javascript = """
480 | // Universal button click handler
481 | function handleButtonClick(e) {
482 | const target = e.target;
483 | if (target.tagName === 'BUTTON' ||
484 | target.type === 'button' ||
485 | target.getAttribute('role') === 'button' ||
486 | target.classList.contains('button')) {
487 | e.preventDefault();
488 | const clickEvent = new MouseEvent('click', {
489 | view: window,
490 | bubbles: true,
491 | cancelable: true
492 | });
493 | target.dispatchEvent(clickEvent);
494 | }
495 | }
496 |
497 | // Universal form submission handler
498 | function handleFormSubmit(e) {
499 | if (e.target.tagName === 'FORM') {
500 | e.preventDefault();
501 | const submitEvent = new Event('submit', {
502 | bubbles: true,
503 | cancelable: true
504 | });
505 | e.target.dispatchEvent(submitEvent);
506 | }
507 | }
508 |
509 | // Add event listeners
510 | document.addEventListener('click', handleButtonClick, true);
511 | document.addEventListener('submit', handleFormSubmit, true);
512 |
513 | // Fix for dynamically added elements
514 | const observer = new MutationObserver(function(mutations) {
515 | mutations.forEach(function(mutation) {
516 | if (mutation.addedNodes.length) {
517 | mutation.addedNodes.forEach(function(node) {
518 | if (node.nodeType === 1) { // Element node
519 | if (node.tagName === 'BUTTON' ||
520 | node.type === 'button' ||
521 | node.getAttribute('role') === 'button' ||
522 | node.classList.contains('button')) {
523 | node.addEventListener('click', handleButtonClick);
524 | }
525 | if (node.tagName === 'FORM') {
526 | node.addEventListener('submit', handleFormSubmit);
527 | }
528 | }
529 | });
530 | }
531 | });
532 | });
533 |
534 | observer.observe(document.body, {
535 | childList: true,
536 | subtree: true
537 | });
538 | """.trimIndent()
539 |
540 | binding.webView.evaluateJavascript(javascript, null)
541 | }
542 |
543 | private fun injectImageHandlingScript() {
544 | val javascript = """
545 | (function() {
546 | let longPressTimer;
547 | let longPressedImage = null;
548 |
549 | // Function to handle image long press
550 | function handleImageLongPress(e) {
551 | const img = e.target;
552 | if (img.tagName === 'IMG') {
553 | longPressedImage = img;
554 |
555 | // Create download button if it doesn't exist
556 | let downloadBtn = document.getElementById('imageDownloadBtn');
557 | if (!downloadBtn) {
558 | downloadBtn = document.createElement('button');
559 | downloadBtn.id = 'imageDownloadBtn';
560 | downloadBtn.innerHTML = 'Download';
561 | downloadBtn.style.cssText = `
562 | position: fixed;
563 | top: 20px;
564 | right: 20px;
565 | z-index: 9999;
566 | padding: 10px 20px;
567 | background-color: #4CAF50;
568 | color: white;
569 | border: none;
570 | border-radius: 5px;
571 | cursor: pointer;
572 | font-size: 16px;
573 | box-shadow: 0 2px 5px rgba(0,0,0,0.2);
574 | `;
575 | document.body.appendChild(downloadBtn);
576 | }
577 |
578 | // Update download button click handler
579 | downloadBtn.onclick = function(e) {
580 | e.preventDefault();
581 | e.stopPropagation();
582 | if (longPressedImage) {
583 | window.location.href = longPressedImage.src;
584 | }
585 | this.remove();
586 | longPressedImage = null;
587 | };
588 |
589 | // Show download button
590 | downloadBtn.style.display = 'block';
591 | }
592 | }
593 |
594 | // Add touch event listeners for long press
595 | document.addEventListener('touchstart', function(e) {
596 | if (e.target.tagName === 'IMG') {
597 | longPressTimer = setTimeout(function() {
598 | handleImageLongPress(e);
599 | }, 500); // 500ms for long press
600 | }
601 | });
602 |
603 | document.addEventListener('touchend', function() {
604 | clearTimeout(longPressTimer);
605 | });
606 |
607 | document.addEventListener('touchmove', function() {
608 | clearTimeout(longPressTimer);
609 | });
610 |
611 | // Remove download button when clicking elsewhere
612 | document.addEventListener('click', function(e) {
613 | const downloadBtn = document.getElementById('imageDownloadBtn');
614 | if (downloadBtn && e.target !== downloadBtn) {
615 | downloadBtn.remove();
616 | longPressedImage = null;
617 | }
618 | }, true);
619 | })();
620 | """.trimIndent()
621 |
622 | binding.webView.evaluateJavascript(javascript, null)
623 | }
624 |
625 | private fun injectLinkHandlingScript() {
626 | val javascript = """
627 | (function() {
628 | window.Android.log('Setting up link handling');
629 |
630 | // Function to handle link clicks
631 | function handleLinkClick(e) {
632 | const target = e.target;
633 | let link = null;
634 |
635 | // Check if clicked element is a link or inside a link
636 | if (target.tagName === 'A') {
637 | link = target;
638 | } else if (target.closest('a')) {
639 | link = target.closest('a');
640 | }
641 |
642 | if (link && link.href) {
643 | const url = link.href;
644 | window.Android.log('Link clicked: ' + url);
645 |
646 | // Check if it's an external link (not same origin)
647 | const currentOrigin = window.location.origin;
648 | const linkUrl = new URL(url, window.location.href);
649 |
650 | if (linkUrl.origin !== currentOrigin) {
651 | e.preventDefault();
652 | e.stopPropagation();
653 | window.Android.openLink(url);
654 | return false;
655 | }
656 | }
657 |
658 | return true;
659 | }
660 |
661 | // Add click listener to document
662 | document.addEventListener('click', handleLinkClick, true);
663 |
664 | // Handle dynamically added links
665 | const observer = new MutationObserver(function(mutations) {
666 | mutations.forEach(function(mutation) {
667 | if (mutation.addedNodes.length) {
668 | mutation.addedNodes.forEach(function(node) {
669 | if (node.nodeType === 1) { // Element node
670 | // Check if the added node is a link
671 | if (node.tagName === 'A') {
672 | node.addEventListener('click', handleLinkClick, true);
673 | }
674 | // Check for links inside the added node
675 | const links = node.querySelectorAll ? node.querySelectorAll('a') : [];
676 | for (let i = 0; i < links.length; i++) {
677 | links[i].addEventListener('click', handleLinkClick, true);
678 | }
679 | }
680 | });
681 | }
682 | });
683 | });
684 |
685 | observer.observe(document.body, {
686 | childList: true,
687 | subtree: true
688 | });
689 |
690 | window.Android.log('Link handling setup complete');
691 | })();
692 | """.trimIndent()
693 |
694 | binding.webView.evaluateJavascript(javascript, null)
695 | }
696 |
697 | private fun showConnectionError() {
698 | Log.e("WebViewActivity", "Connection failed or timed out")
699 | binding.webView.loadUrl("about:blank")
700 | }
701 |
702 | private fun handleIntent(intent: Intent) {
703 | Log.d("WebViewActivity", "Handling intent: ${intent.action}")
704 |
705 | when (intent.action) {
706 | Intent.ACTION_VIEW -> {
707 | val uri = intent.data
708 | if (uri != null) {
709 | Log.d("WebViewActivity", "Received URL: $uri")
710 | if (isWebViewReady) {
711 | loadUrl(uri)
712 | } else {
713 | binding.webView.post {
714 | loadUrl(uri)
715 | }
716 | }
717 | }
718 | }
719 | Intent.ACTION_SEND -> {
720 | when {
721 | intent.type?.startsWith("image/") == true -> {
722 | val imageUri = intent.getParcelableExtra(Intent.EXTRA_STREAM, Uri::class.java)
723 | imageUri?.let { uri ->
724 | Log.d("WebViewActivity", "Received image URI: $uri")
725 | if (isWebViewReady) {
726 | sendImageToWebView(uri)
727 | } else {
728 | binding.webView.post {
729 | sendImageToWebView(uri)
730 | }
731 | }
732 | }
733 | }
734 | intent.type == "text/plain" -> {
735 | val text = intent.getStringExtra(Intent.EXTRA_TEXT)
736 | text?.let {
737 | Log.d("WebViewActivity", "Received text: $it")
738 | if (isWebViewReady) {
739 | sendTextToWebView(it)
740 | } else {
741 | binding.webView.post {
742 | sendTextToWebView(it)
743 | }
744 | }
745 | }
746 | }
747 | }
748 | }
749 | Intent.ACTION_SEND_MULTIPLE -> {
750 | val imageUris = intent.getParcelableArrayListExtra(Intent.EXTRA_STREAM, Uri::class.java)
751 | imageUris?.let { uris ->
752 | Log.d("WebViewActivity", "Received multiple images: ${uris.size}")
753 | if (isWebViewReady) {
754 | sendMultipleImagesToWebView(uris)
755 | } else {
756 | binding.webView.post {
757 | sendMultipleImagesToWebView(uris)
758 | }
759 | }
760 | }
761 | }
762 | }
763 | }
764 |
765 | private fun loadUrl(uri: Uri) {
766 | try {
767 | val processedUrl = when (uri.scheme) {
768 | "openwebui" -> {
769 | // Handle openwebui:// scheme
770 | val host = uri.host
771 | if (host != null && HOST_PATTERN.matcher(host).matches()) {
772 | "https://$host${uri.path}${uri.query?.let { "?$it" } ?: ""}"
773 | } else {
774 | Log.e("WebViewActivity", "Invalid host in openwebui:// URL: $host")
775 | return
776 | }
777 | }
778 | else -> {
779 | // Use the URL exactly as provided
780 | uri.toString()
781 | }
782 | }
783 |
784 | // Validate and process URL parameters
785 | val finalUrl = processUrlParameters(processedUrl)
786 | Log.d("WebViewActivity", "Loading final URL: $finalUrl")
787 |
788 | // Set up WebViewClient with error handling
789 | binding.webView.webViewClient = object : WebViewClient() {
790 | override fun onReceivedError(
791 | view: WebView?,
792 | request: WebResourceRequest?,
793 | error: WebResourceError?
794 | ) {
795 | super.onReceivedError(view, request, error)
796 | timeoutHandler.removeCallbacks(timeoutRunnable)
797 | Log.e("WebViewActivity", "WebView error: ${error?.description}")
798 | showConnectionError()
799 | }
800 |
801 | override fun onPageFinished(view: WebView?, url: String?) {
802 | timeoutHandler.removeCallbacks(timeoutRunnable)
803 | binding.progressBar.isVisible = false
804 | binding.webView.alpha = 1f
805 | isWebViewReady = true
806 | Log.d("WebViewActivity", "WebView loaded: $url")
807 | injectImageHandlingScript()
808 | injectLinkHandlingScript()
809 | }
810 |
811 | override fun shouldOverrideUrlLoading(view: WebView?, url: String?): Boolean {
812 | if (url?.startsWith(baseUrl) == true) {
813 | return false
814 | }
815 | url?.let {
816 | val intent = Intent(Intent.ACTION_VIEW, Uri.parse(it))
817 | startActivity(intent)
818 | }
819 | return true
820 | }
821 | }
822 |
823 | binding.webView.loadUrl(finalUrl)
824 | } catch (e: Exception) {
825 | Log.e("WebViewActivity", "Error loading URL", e)
826 | }
827 | }
828 |
829 | private fun processUrlParameters(url: String): String {
830 | try {
831 | val uri = Uri.parse(url)
832 | val queryParams = uri.queryParameterNames
833 | val processedParams = mutableMapOf()
834 |
835 | // Process each parameter
836 | for (param in queryParams) {
837 | when (param) {
838 | "models", "model" -> {
839 | // Validate model names
840 | val models = uri.getQueryParameter(param)?.split(",")?.filter { it.isNotBlank() }
841 | if (!models.isNullOrEmpty()) {
842 | val validModels = models.filter { MODEL_NAME_PATTERN.matcher(it).matches() }
843 | if (validModels.isNotEmpty()) {
844 | processedParams[param] = validModels.joinToString(",")
845 | Log.d("WebViewActivity", "Validated models: $validModels")
846 | } else {
847 | Log.w("WebViewActivity", "No valid models found in: $models")
848 | }
849 | }
850 | }
851 | "youtube" -> {
852 | // Validate YouTube video ID
853 | val videoId = uri.getQueryParameter(param)
854 | if (!videoId.isNullOrBlank() && YOUTUBE_ID_PATTERN.matcher(videoId).matches()) {
855 | processedParams[param] = videoId
856 | Log.d("WebViewActivity", "Validated YouTube ID: $videoId")
857 | } else {
858 | Log.w("WebViewActivity", "Invalid YouTube ID: $videoId")
859 | }
860 | }
861 | "web-search" -> {
862 | // Validate web-search parameter
863 | val webSearch = uri.getQueryParameter(param)
864 | if (webSearch == "true") {
865 | processedParams[param] = "true"
866 | Log.d("WebViewActivity", "Web search enabled")
867 | } else {
868 | Log.w("WebViewActivity", "Invalid web-search value: $webSearch")
869 | }
870 | }
871 | "tools", "tool-ids" -> {
872 | // Validate tool IDs
873 | val tools = uri.getQueryParameter(param)?.split(",")?.filter { it.isNotBlank() }
874 | if (!tools.isNullOrEmpty()) {
875 | val validTools = tools.filter { TOOL_ID_PATTERN.matcher(it).matches() }
876 | if (validTools.isNotEmpty()) {
877 | processedParams[param] = validTools.joinToString(",")
878 | Log.d("WebViewActivity", "Validated tools: $validTools")
879 | } else {
880 | Log.w("WebViewActivity", "No valid tools found in: $tools")
881 | }
882 | }
883 | }
884 | "call" -> {
885 | // Validate call parameter
886 | val call = uri.getQueryParameter(param)
887 | if (call == "true") {
888 | processedParams[param] = "true"
889 | Log.d("WebViewActivity", "Call overlay enabled")
890 | } else {
891 | Log.w("WebViewActivity", "Invalid call value: $call")
892 | }
893 | }
894 | "q" -> {
895 | // Validate query parameter
896 | val query = uri.getQueryParameter(param)
897 | if (!query.isNullOrBlank() && QUERY_PATTERN.matcher(query).matches()) {
898 | processedParams[param] = query
899 | Log.d("WebViewActivity", "Validated query: $query")
900 | } else {
901 | Log.w("WebViewActivity", "Invalid query: $query")
902 | }
903 | }
904 | "temporary-chat" -> {
905 | // Validate temporary-chat parameter
906 | val tempChat = uri.getQueryParameter(param)
907 | if (tempChat == "true") {
908 | processedParams[param] = "true"
909 | Log.d("WebViewActivity", "Temporary chat enabled")
910 | } else {
911 | Log.w("WebViewActivity", "Invalid temporary-chat value: $tempChat")
912 | }
913 | }
914 | }
915 | }
916 |
917 | // Rebuild the URL with processed parameters
918 | val baseUrl = uri.buildUpon().clearQuery()
919 | for ((key, value) in processedParams) {
920 | baseUrl.appendQueryParameter(key, value)
921 | }
922 |
923 | val finalUrl = baseUrl.build().toString()
924 | Log.d("WebViewActivity", "Final processed URL: $finalUrl")
925 | return finalUrl
926 | } catch (e: Exception) {
927 | Log.e("WebViewActivity", "Error processing URL parameters", e)
928 | return url
929 | }
930 | }
931 |
932 | private fun sendImageToWebView(uri: Uri) {
933 | try {
934 | val shareData = JSONObject().apply {
935 | put("type", "image")
936 | put("uri", uri.toString())
937 | put("model", getSelectedModel())
938 | put("prefilledMessage", getPrefilledMessage("image"))
939 | }
940 | Log.d("WebViewActivity", "Sending image data: ${shareData.toString()}")
941 | injectShareData(shareData)
942 | } catch (e: Exception) {
943 | Log.e("WebViewActivity", "Error sending image to WebView", e)
944 | }
945 | }
946 |
947 | private fun sendTextToWebView(text: String) {
948 | try {
949 | val shareData = JSONObject().apply {
950 | put("type", "text")
951 | put("content", text)
952 | put("model", getSelectedModel())
953 | put("prefilledMessage", getPrefilledMessage("text"))
954 | }
955 | Log.d("WebViewActivity", "Sending text data: ${shareData.toString()}")
956 | injectShareData(shareData)
957 | } catch (e: Exception) {
958 | Log.e("WebViewActivity", "Error sending text to WebView", e)
959 | }
960 | }
961 |
962 | private fun sendMultipleImagesToWebView(uris: ArrayList) {
963 | try {
964 | val uriStrings = uris.map { it.toString() }
965 | val shareData = JSONObject().apply {
966 | put("type", "multiple_images")
967 | put("uris", uriStrings)
968 | put("model", getSelectedModel())
969 | put("prefilledMessage", getPrefilledMessage("image"))
970 | }
971 | Log.d("WebViewActivity", "Sending multiple images data: ${shareData.toString()}")
972 | injectShareData(shareData)
973 | } catch (e: Exception) {
974 | Log.e("WebViewActivity", "Error sending multiple images to WebView", e)
975 | }
976 | }
977 |
978 | private fun injectShareData(shareData: JSONObject) {
979 | try {
980 | val javascript = """
981 | if (window.handleSharedContent) {
982 | window.handleSharedContent(${shareData.toString()});
983 | } else {
984 | console.error('handleSharedContent function not found');
985 | }
986 | """.trimIndent()
987 |
988 | Log.d("WebViewActivity", "Injecting JavaScript: $javascript")
989 | binding.webView.evaluateJavascript(javascript) { result ->
990 | Log.d("WebViewActivity", "JavaScript evaluation result: $result")
991 | }
992 | } catch (e: Exception) {
993 | Log.e("WebViewActivity", "Error injecting share data", e)
994 | }
995 | }
996 |
997 | private fun getSelectedModel(): String {
998 | return getSharedPreferences("OpenWebUIClient", MODE_PRIVATE)
999 | .getString("selected_model", "default") ?: "default"
1000 | }
1001 |
1002 | private fun getPrefilledMessage(type: String): String {
1003 | return getSharedPreferences("OpenWebUIClient", MODE_PRIVATE)
1004 | .getString("prefilled_message_$type", "") ?: ""
1005 | }
1006 |
1007 | override fun onNewIntent(intent: Intent?) {
1008 | super.onNewIntent(intent)
1009 | Log.d("WebViewActivity", "New intent received")
1010 | intent?.let { handleIntent(it) }
1011 | }
1012 |
1013 | override fun onDestroy() {
1014 | timeoutHandler.removeCallbacks(timeoutRunnable)
1015 | binding.webView.destroy()
1016 | super.onDestroy()
1017 | }
1018 |
1019 | @Deprecated("Deprecated in Java", ReplaceWith("handleTouchEvent(event)"))
1020 | private fun handleTouchEvent(event: MotionEvent): Boolean {
1021 | when (event.actionMasked) {
1022 | MotionEvent.ACTION_DOWN, MotionEvent.ACTION_POINTER_DOWN -> {
1023 | val pointerId = event.getPointerId(event.actionIndex)
1024 | activePointers.add(pointerId)
1025 | Log.d("WebViewActivity", "Pointer down: $pointerId, Total pointers: ${activePointers.size}")
1026 |
1027 | if (activePointers.size == REQUIRED_FINGERS) {
1028 | longPressStartTime = System.currentTimeMillis()
1029 | isLongPressing = true
1030 | showLongPressIndicator()
1031 | startProgressUpdate()
1032 | }
1033 | }
1034 | MotionEvent.ACTION_UP, MotionEvent.ACTION_POINTER_UP -> {
1035 | val pointerId = event.getPointerId(event.actionIndex)
1036 | activePointers.remove(pointerId)
1037 | Log.d("WebViewActivity", "Pointer up: $pointerId, Total pointers: ${activePointers.size}")
1038 |
1039 | if (activePointers.size < REQUIRED_FINGERS) {
1040 | isLongPressing = false
1041 | hideLongPressIndicator()
1042 | timeoutHandler.removeCallbacksAndMessages(null)
1043 | }
1044 | }
1045 | MotionEvent.ACTION_CANCEL -> {
1046 | activePointers.clear()
1047 | isLongPressing = false
1048 | hideLongPressIndicator()
1049 | timeoutHandler.removeCallbacksAndMessages(null)
1050 | }
1051 | }
1052 | return false
1053 | }
1054 |
1055 | private fun showLongPressIndicator() {
1056 | val indicatorBinding = LongPressIndicatorBinding.inflate(layoutInflater)
1057 | longPressIndicator = AlertDialog.Builder(this)
1058 | .setView(indicatorBinding.root)
1059 | .setCancelable(false)
1060 | .create()
1061 | longPressIndicator?.show()
1062 | }
1063 |
1064 | private fun hideLongPressIndicator() {
1065 | longPressIndicator?.dismiss()
1066 | longPressIndicator = null
1067 | progressUpdateRunnable?.let { timeoutHandler.removeCallbacks(it) }
1068 | }
1069 |
1070 | private fun startProgressUpdate() {
1071 | val indicatorBinding = LongPressIndicatorBinding.inflate(layoutInflater)
1072 | progressUpdateRunnable = object : Runnable {
1073 | override fun run() {
1074 | if (isLongPressing) {
1075 | val elapsed = System.currentTimeMillis() - longPressStartTime
1076 | val progress = (elapsed * 100 / LONG_PRESS_DURATION).toInt()
1077 | indicatorBinding.progressBar.progress = progress.coerceAtMost(100)
1078 |
1079 | if (elapsed >= LONG_PRESS_DURATION) {
1080 | showSettingsDialog()
1081 | hideLongPressIndicator()
1082 | } else {
1083 | timeoutHandler.postDelayed(this, 16) // Update every 16ms
1084 | }
1085 | }
1086 | }
1087 | }
1088 | timeoutHandler.post(progressUpdateRunnable!!)
1089 | }
1090 |
1091 | private fun showSettingsDialog() {
1092 | val dialogBinding = DialogSettingsBinding.inflate(layoutInflater)
1093 | val currentUrl = getSharedPreferences("AppPrefs", MODE_PRIVATE)
1094 | .getString("SAVED_URL", "") ?: ""
1095 |
1096 | dialogBinding.serverUrlInput.setText(currentUrl)
1097 |
1098 | val dialog = AlertDialog.Builder(this)
1099 | .setView(dialogBinding.root)
1100 | .setCancelable(true)
1101 | .create()
1102 |
1103 | dialogBinding.cancelButton.setOnClickListener {
1104 | dialog.dismiss()
1105 | }
1106 |
1107 | dialogBinding.saveButton.setOnClickListener {
1108 | val newUrl = dialogBinding.serverUrlInput.text.toString().trim()
1109 | if (newUrl.isNotEmpty()) {
1110 | saveServerUrl(newUrl)
1111 | dialog.dismiss()
1112 | // Reload WebView with new URL
1113 | binding.webView.loadUrl(newUrl)
1114 | // Reset WebView state
1115 | isWebViewReady = false
1116 | binding.progressBar.isVisible = true
1117 | binding.webView.alpha = 0f
1118 | }
1119 | }
1120 |
1121 | dialog.show()
1122 | }
1123 |
1124 | private fun validateUrl(url: String): Boolean {
1125 | return URL_PATTERN.matcher(url).matches()
1126 | }
1127 |
1128 | private fun saveServerUrl(url: String) {
1129 | getSharedPreferences("AppPrefs", MODE_PRIVATE)
1130 | .edit()
1131 | .putString("SAVED_URL", url)
1132 | .apply()
1133 | }
1134 |
1135 | private fun checkCameraPermission(): Boolean {
1136 | return ContextCompat.checkSelfPermission(
1137 | this,
1138 | Manifest.permission.CAMERA
1139 | ) == PackageManager.PERMISSION_GRANTED
1140 | }
1141 |
1142 | private fun requestCameraPermission() {
1143 | requestPermissionLauncher.launch(Manifest.permission.CAMERA)
1144 | }
1145 |
1146 | private fun launchCamera() {
1147 | try {
1148 | val imageFile = createImageFile()
1149 | Log.d("WebViewActivity", "Created image file: ${imageFile.absolutePath}")
1150 |
1151 | cameraImageUri = FileProvider.getUriForFile(
1152 | this,
1153 | "${packageName}.provider",
1154 | imageFile
1155 | )
1156 | Log.d("WebViewActivity", "Created camera URI: $cameraImageUri")
1157 |
1158 | // Grant URI permissions
1159 | val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply {
1160 | putExtra(MediaStore.EXTRA_OUTPUT, cameraImageUri)
1161 | addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
1162 | addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
1163 | }
1164 |
1165 | // Check if there's a camera app available
1166 | if (takePictureIntent.resolveActivity(packageManager) != null) {
1167 | cameraLauncher.launch(cameraImageUri)
1168 | Log.d("WebViewActivity", "Launched camera")
1169 | } else {
1170 | Log.e("WebViewActivity", "No camera app available")
1171 | filePathCallback?.onReceiveValue(null)
1172 | filePathCallback = null
1173 | }
1174 | } catch (e: Exception) {
1175 | Log.e("WebViewActivity", "Error launching camera", e)
1176 | filePathCallback?.onReceiveValue(null)
1177 | filePathCallback = null
1178 | }
1179 | }
1180 |
1181 | private fun injectMicrophonePermissionGranted() {
1182 | val javascript = """
1183 | window.Android.log('Microphone permission granted');
1184 | if (window.handleMicrophoneAccess) {
1185 | window.handleMicrophoneAccess().then(function() {
1186 | window.Android.log('Microphone access resolved');
1187 | }).catch(function(error) {
1188 | window.Android.log('Microphone access error: ' + error);
1189 | });
1190 | }
1191 | """.trimIndent()
1192 | binding.webView.evaluateJavascript(javascript, null)
1193 | }
1194 |
1195 | private fun injectMicrophonePermissionDenied() {
1196 | val javascript = """
1197 | window.Android.log('Microphone permission denied');
1198 | if (window.handleMicrophoneAccess) {
1199 | window.handleMicrophoneAccess().catch(function(error) {
1200 | window.Android.log('Microphone access error: ' + error);
1201 | });
1202 | }
1203 | """.trimIndent()
1204 | binding.webView.evaluateJavascript(javascript, null)
1205 | }
1206 |
1207 | private fun checkMicrophonePermission(): Boolean {
1208 | return ContextCompat.checkSelfPermission(
1209 | this,
1210 | Manifest.permission.RECORD_AUDIO
1211 | ) == PackageManager.PERMISSION_GRANTED
1212 | }
1213 |
1214 | private fun requestMicrophonePermission() {
1215 | requestPermissionLauncher.launch(Manifest.permission.RECORD_AUDIO)
1216 | }
1217 | }
--------------------------------------------------------------------------------
62 |
63 | 