app/src/main/java/com/farmerbb/taskbar/ui/TaskbarController.java

   1 /* Copyright 2016 Braden Farmer
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 package com.farmerbb.taskbar.ui;
  17
  18 import android.accessibilityservice.AccessibilityService;
  19 import android.annotation.SuppressLint;
  20 import android.annotation.TargetApi;
  21 import android.app.ActivityManager;
  22 import android.app.AlarmManager;
  23 import android.app.usage.UsageEvents;
  24 import android.app.usage.UsageStats;
  25 import android.app.usage.UsageStatsManager;
  26 import android.bluetooth.BluetoothAdapter;
  27 import android.content.ActivityNotFoundException;
  28 import android.content.BroadcastReceiver;
  29 import android.content.Context;
  30 import android.content.Intent;
  31 import android.content.IntentFilter;
  32 import android.content.SharedPreferences;
  33 import android.content.pm.LauncherActivityInfo;
  34 import android.content.pm.LauncherApps;
  35 import android.content.pm.PackageManager;
  36 import android.content.pm.ResolveInfo;
  37 import android.content.res.Resources;
  38 import android.graphics.Bitmap;
  39 import android.graphics.BitmapFactory;
  40 import android.graphics.Color;
  41 import android.graphics.Point;
  42 import android.graphics.Typeface;
  43 import android.graphics.drawable.BitmapDrawable;
  44 import android.graphics.drawable.Drawable;
  45 import android.net.ConnectivityManager;
  46 import android.net.NetworkInfo;
  47 import android.net.wifi.WifiInfo;
  48 import android.net.wifi.WifiManager;
  49 import android.os.BatteryManager;
  50 import android.os.Build;
  51 import android.os.Bundle;
  52 import android.os.Handler;
  53 import android.os.PowerManager;
  54 import android.os.Process;
  55 import android.os.SystemClock;
  56 import android.os.UserHandle;
  57 import android.os.UserManager;
  58 import android.provider.Settings;
  59 import android.speech.RecognizerIntent;
  60 import androidx.core.content.ContextCompat;
  61 import androidx.core.graphics.ColorUtils;
  62 import android.telephony.PhoneStateListener;
  63 import android.telephony.SignalStrength;
  64 import android.telephony.TelephonyManager;
  65 import android.text.format.DateFormat;
  66 import android.view.Display;
  67 import android.view.Gravity;
  68 import android.view.LayoutInflater;
  69 import android.view.MotionEvent;
  70 import android.view.PointerIcon;
  71 import android.view.View;
  72 import android.view.ViewGroup;
  73 import android.view.WindowManager;
  74 import android.view.inputmethod.InputMethodManager;
  75 import android.widget.Button;
  76 import android.widget.FrameLayout;
  77 import android.widget.ImageView;
  78
  79 import java.io.File;
  80 import java.lang.reflect.Field;
  81 import java.util.ArrayList;
  82 import java.util.Collections;
  83 import java.util.Date;
  84 import java.util.List;
  85
  86 import androidx.localbroadcastmanager.content.LocalBroadcastManager;
  87 import android.widget.LinearLayout;
  88 import android.widget.Space;
  89 import android.widget.TextView;
  90
  91 import com.farmerbb.taskbar.BuildConfig;
  92 import com.farmerbb.taskbar.activity.HomeActivityDelegate;
  93 import com.farmerbb.taskbar.activity.MainActivity;
  94 import com.farmerbb.taskbar.R;
  95 import com.farmerbb.taskbar.activity.HomeActivity;
  96 import com.farmerbb.taskbar.activity.InvisibleActivityFreeform;
  97 import com.farmerbb.taskbar.activity.SecondaryHomeActivity;
  98 import com.farmerbb.taskbar.content.TaskbarIntent;
  99 import com.farmerbb.taskbar.util.AppEntry;
 100 import com.farmerbb.taskbar.util.DisplayInfo;
 101 import com.farmerbb.taskbar.util.FreeformHackHelper;
 102 import com.farmerbb.taskbar.util.IconCache;
 103 import com.farmerbb.taskbar.util.LauncherHelper;
 104 import com.farmerbb.taskbar.util.PinnedBlockedApps;
 105 import com.farmerbb.taskbar.util.MenuHelper;
 106 import com.farmerbb.taskbar.util.U;
 107
 108 public class TaskbarController implements UIController {
 109
 110     private Context context;
 111     private LinearLayout layout;
 112     private ImageView startButton;
 113     private LinearLayout taskbar;
 114     private FrameLayout scrollView;
 115     private Button button;
 116     private Space space;
 117     private FrameLayout dashboardButton;
 118     private LinearLayout navbarButtons;
 119     private LinearLayout sysTrayLayout;
 120     private FrameLayout sysTrayParentLayout;
 121     private TextView time;
 122
 123     private Handler handler;
 124     private Handler handler2;
 125     private Thread thread;
 126     private Thread thread2;
 127
 128     private boolean isShowingRecents = true;
 129     private boolean shouldRefreshRecents = true;
 130     private boolean taskbarShownTemporarily = false;
 131     private boolean taskbarHiddenTemporarily = false;
 132     private boolean isRefreshingRecents = false;
 133     private boolean isFirstStart = true;
 134
 135     private boolean startThread2 = false;
 136     private boolean stopThread2 = false;
 137
 138     private int refreshInterval = -1;
 139     private long searchInterval = -1;
 140     private String sortOrder = "false";
 141     private boolean runningAppsOnly = false;
 142
 143     private int layoutId = R.layout.tb_taskbar_left;
 144     private int currentTaskbarPosition = 0;
 145     private boolean showHideAutomagically = false;
 146     private boolean positionIsVertical = false;
 147     private boolean dashboardEnabled = false;
 148     private boolean navbarButtonsEnabled = false;
 149     private boolean sysTrayEnabled = false;
 150
 151     private List<String> currentTaskbarIds = new ArrayList<>();
 152     private int numOfPinnedApps = -1;
 153
 154     private int cellStrength = -1;
 155
 156     private View.OnClickListener ocl = view -> {
 157         Intent intent = new Intent("com.farmerbb.taskbar.TOGGLE_START_MENU");
 158         LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
 159     };
 160
 161     private BroadcastReceiver showReceiver = new BroadcastReceiver() {
 162         @Override
 163         public void onReceive(Context context, Intent intent) {
 164             showTaskbar(true);
 165         }
 166     };
 167
 168     private BroadcastReceiver hideReceiver = new BroadcastReceiver() {
 169         @Override
 170         public void onReceive(Context context, Intent intent) {
 171             hideTaskbar(true);
 172         }
 173     };
 174
 175     private BroadcastReceiver tempShowReceiver = new BroadcastReceiver() {
 176         @Override
 177         public void onReceive(Context context, Intent intent) {
 178             tempShowTaskbar();
 179         }
 180     };
 181
 182     private BroadcastReceiver tempHideReceiver = new BroadcastReceiver() {
 183         @Override
 184         public void onReceive(Context context, Intent intent) {
 185             tempHideTaskbar(false);
 186         }
 187     };
 188
 189     private BroadcastReceiver startMenuAppearReceiver = new BroadcastReceiver() {
 190         @Override
 191         public void onReceive(Context context, Intent intent) {
 192             if(startButton.getVisibility() == View.GONE
 193                     && (!LauncherHelper.getInstance().isOnHomeScreen() || FreeformHackHelper.getInstance().isInFreeformWorkspace()))
 194                 layout.setVisibility(View.GONE);
 195         }
 196     };
 197
 198     private BroadcastReceiver startMenuDisappearReceiver = new BroadcastReceiver() {
 199         @Override
 200         public void onReceive(Context context, Intent intent) {
 201             if(startButton.getVisibility() == View.GONE)
 202                 layout.setVisibility(View.VISIBLE);
 203         }
 204     };
 205
 206     @TargetApi(Build.VERSION_CODES.M)
 207     private PhoneStateListener listener = new PhoneStateListener() {
 208         @Override
 209         public void onSignalStrengthsChanged(SignalStrength signalStrength) {
 210             try {
 211                 cellStrength = signalStrength.getLevel();
 212             } catch (SecurityException e) {
 213                 cellStrength = -1;
 214             }
 215         }
 216     };
 217
 218     public TaskbarController(Context context) {
 219         this.context = context;
 220     }
 221
 222     @TargetApi(Build.VERSION_CODES.M)
 223     @Override
 224     public void onCreateHost(UIHost host) {
 225         SharedPreferences pref = U.getSharedPreferences(context);
 226         if(pref.getBoolean("taskbar_active", false) || LauncherHelper.getInstance().isOnHomeScreen()) {
 227             if(U.canDrawOverlays(context))
 228                 drawTaskbar(host);
 229             else {
 230                 pref.edit().putBoolean("taskbar_active", false).apply();
 231
 232                 host.terminate();
 233             }
 234         } else host.terminate();
 235     }
 236
 237     @SuppressLint("RtlHardcoded")
 238     private void drawTaskbar(UIHost host) {
 239         IconCache.getInstance(context).clearCache();
 240
 241         // Initialize layout params
 242         WindowManager windowManager = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
 243         U.setCachedRotation(windowManager.getDefaultDisplay().getRotation());
 244
 245         final ViewParams params = new ViewParams(
 246                 WindowManager.LayoutParams.WRAP_CONTENT,
 247                 WindowManager.LayoutParams.WRAP_CONTENT,
 248                 -1,
 249                 WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE | WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM
 250         );
 251
 252         // Determine where to show the taskbar on screen
 253         switch(U.getTaskbarPosition(context)) {
 254             case "bottom_left":
 255                 layoutId = R.layout.tb_taskbar_left;
 256                 params.gravity = Gravity.BOTTOM | Gravity.LEFT;
 257                 positionIsVertical = false;
 258                 break;
 259             case "bottom_vertical_left":
 260                 layoutId = R.layout.tb_taskbar_vertical;
 261                 params.gravity = Gravity.BOTTOM | Gravity.LEFT;
 262                 positionIsVertical = true;
 263                 break;
 264             case "bottom_right":
 265                 layoutId = R.layout.tb_taskbar_right;
 266                 params.gravity = Gravity.BOTTOM | Gravity.RIGHT;
 267                 positionIsVertical = false;
 268                 break;
 269             case "bottom_vertical_right":
 270                 layoutId = R.layout.tb_taskbar_vertical;
 271                 params.gravity = Gravity.BOTTOM | Gravity.RIGHT;
 272                 positionIsVertical = true;
 273                 break;
 274             case "top_left":
 275                 layoutId = R.layout.tb_taskbar_left;
 276                 params.gravity = Gravity.TOP | Gravity.LEFT;
 277                 positionIsVertical = false;
 278                 break;
 279             case "top_vertical_left":
 280                 layoutId = R.layout.tb_taskbar_top_vertical;
 281                 params.gravity = Gravity.TOP | Gravity.LEFT;
 282                 positionIsVertical = true;
 283                 break;
 284             case "top_right":
 285                 layoutId = R.layout.tb_taskbar_right;
 286                 params.gravity = Gravity.TOP | Gravity.RIGHT;
 287                 positionIsVertical = false;
 288                 break;
 289             case "top_vertical_right":
 290                 layoutId = R.layout.tb_taskbar_top_vertical;
 291                 params.gravity = Gravity.TOP | Gravity.RIGHT;
 292                 positionIsVertical = true;
 293                 break;
 294         }
 295
 296         // Initialize views
 297         SharedPreferences pref = U.getSharedPreferences(context);
 298         boolean altButtonConfig = pref.getBoolean("alt_button_config", false);
 299
 300         layout = (LinearLayout) LayoutInflater.from(U.wrapContext(context)).inflate(layoutId, null);
 301         taskbar = layout.findViewById(R.id.taskbar);
 302         scrollView = layout.findViewById(R.id.taskbar_scrollview);
 303
 304         int backgroundTint = U.getBackgroundTint(context);
 305         int accentColor = U.getAccentColor(context);
 306
 307         if(altButtonConfig) {
 308             space = layout.findViewById(R.id.space_alt);
 309             layout.findViewById(R.id.space).setVisibility(View.GONE);
 310         } else {
 311             space = layout.findViewById(R.id.space);
 312             layout.findViewById(R.id.space_alt).setVisibility(View.GONE);
 313         }
 314
 315         space.setOnClickListener(v -> toggleTaskbar(true));
 316
 317         startButton = layout.findViewById(R.id.start_button);
 318         int padding = 0;
 319
 320         switch(pref.getString("start_button_image", U.getDefaultStartButtonImage(context))) {
 321             case "default":
 322                 startButton.setImageDrawable(ContextCompat.getDrawable(context, R.drawable.tb_all_apps_button_icon));
 323                 padding = context.getResources().getDimensionPixelSize(R.dimen.tb_app_drawer_icon_padding);
 324                 break;
 325             case "app_logo":
 326                 Drawable drawable;
 327
 328                 if(U.isBlissOs(context)) {
 329                     drawable = ContextCompat.getDrawable(context, R.drawable.tb_bliss);
 330                     drawable.setTint(accentColor);
 331                 } else {
 332                     LauncherApps launcherApps = (LauncherApps) context.getSystemService(Context.LAUNCHER_APPS_SERVICE);
 333                     LauncherActivityInfo info = launcherApps.getActivityList(context.getPackageName(), Process.myUserHandle()).get(0);
 334                     drawable = IconCache.getInstance(context).getIcon(context, context.getPackageManager(), info);
 335                 }
 336
 337                 startButton.setImageDrawable(drawable);
 338                 padding = context.getResources().getDimensionPixelSize(R.dimen.tb_app_drawer_icon_padding_alt);
 339                 break;
 340             case "custom":
 341                 File file = new File(context.getFilesDir() + "/tb_images", "custom_image");
 342                 if(file.exists()) {
 343                     Handler handler = new Handler();
 344                     new Thread(() -> {
 345                         Bitmap bitmap = BitmapFactory.decodeFile(file.getPath());
 346                         handler.post(() -> {
 347                             if(bitmap != null) {
 348                                 BitmapDrawable bitmapDrawable = new BitmapDrawable(context.getResources(), bitmap);
 349                                 bitmapDrawable.setFilterBitmap(bitmap.getWidth() * bitmap.getHeight() > 2000);
 350                                 startButton.setImageDrawable(bitmapDrawable);
 351                             } else {
 352                                 U.showToastLong(context, R.string.tb_error_reading_custom_start_image);
 353                                 startButton.setImageDrawable(ContextCompat.getDrawable(context, R.drawable.tb_all_apps_button_icon));
 354                             }
 355                         });
 356                     }).start();
 357                 } else
 358                     startButton.setImageDrawable(ContextCompat.getDrawable(context, R.drawable.tb_all_apps_button_icon));
 359
 360                 padding = context.getResources().getDimensionPixelSize(R.dimen.tb_app_drawer_icon_padding);
 361                 break;
 362         }
 363
 364         startButton.setPadding(padding, padding, padding, padding);
 365         startButton.setOnClickListener(ocl);
 366         startButton.setOnLongClickListener(view -> {
 367             openContextMenu();
 368             return true;
 369         });
 370
 371         startButton.setOnGenericMotionListener((view, motionEvent) -> {
 372             if(motionEvent.getAction() == MotionEvent.ACTION_BUTTON_PRESS
 373                     && motionEvent.getButtonState() == MotionEvent.BUTTON_SECONDARY)
 374                 openContextMenu();
 375
 376             return false;
 377         });
 378
 379         refreshInterval = (int) (Float.parseFloat(pref.getString("refresh_frequency", "1")) * 1000);
 380         if(refreshInterval == 0)
 381             refreshInterval = 100;
 382
 383         sortOrder = pref.getString("sort_order", "false");
 384         runningAppsOnly = pref.getString("recents_amount", "past_day").equals("running_apps_only");
 385
 386         switch(pref.getString("recents_amount", "past_day")) {
 387             case "past_day":
 388                 searchInterval = System.currentTimeMillis() - AlarmManager.INTERVAL_DAY;
 389                 break;
 390             case "app_start":
 391                 long appStartTime = pref.getLong("time_of_service_start", System.currentTimeMillis());
 392                 long deviceStartTime = System.currentTimeMillis() - SystemClock.elapsedRealtime();
 393
 394                 searchInterval = deviceStartTime > appStartTime ? deviceStartTime : appStartTime;
 395                 break;
 396             case "show_all":
 397                 searchInterval = 0;
 398                 break;
 399         }
 400
 401         LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(context);
 402         lbm.sendBroadcast(new Intent(TaskbarIntent.ACTION_HIDE_START_MENU));
 403         lbm.sendBroadcast(new Intent("com.farmerbb.taskbar.UPDATE_HOME_SCREEN_MARGINS"));
 404
 405         if(altButtonConfig) {
 406             button = layout.findViewById(R.id.hide_taskbar_button_alt);
 407             layout.findViewById(R.id.hide_taskbar_button).setVisibility(View.GONE);
 408         } else {
 409             button = layout.findViewById(R.id.hide_taskbar_button);
 410             layout.findViewById(R.id.hide_taskbar_button_alt).setVisibility(View.GONE);
 411         }
 412
 413         try {
 414             button.setTypeface(Typeface.createFromFile("/system/fonts/Roboto-Regular.ttf"));
 415         } catch (RuntimeException e) { /* Gracefully fail */ }
 416
 417         updateButton(false);
 418         button.setOnClickListener(v -> toggleTaskbar(true));
 419
 420         LinearLayout buttonLayout = layout.findViewById(altButtonConfig
 421                 ? R.id.hide_taskbar_button_layout_alt
 422                 : R.id.hide_taskbar_button_layout);
 423         if(buttonLayout != null) buttonLayout.setOnClickListener(v -> toggleTaskbar(true));
 424
 425         LinearLayout buttonLayoutToHide = layout.findViewById(altButtonConfig
 426                 ? R.id.hide_taskbar_button_layout
 427                 : R.id.hide_taskbar_button_layout_alt);
 428         if(buttonLayoutToHide != null) buttonLayoutToHide.setVisibility(View.GONE);
 429
 430         dashboardButton = layout.findViewById(R.id.dashboard_button);
 431         navbarButtons = layout.findViewById(R.id.navbar_buttons);
 432
 433         dashboardEnabled = pref.getBoolean("dashboard", context.getResources().getBoolean(R.bool.tb_def_dashboard));
 434         if(dashboardEnabled) {
 435             layout.findViewById(R.id.square1).setBackgroundColor(accentColor);
 436             layout.findViewById(R.id.square2).setBackgroundColor(accentColor);
 437             layout.findViewById(R.id.square3).setBackgroundColor(accentColor);
 438             layout.findViewById(R.id.square4).setBackgroundColor(accentColor);
 439             layout.findViewById(R.id.square5).setBackgroundColor(accentColor);
 440             layout.findViewById(R.id.square6).setBackgroundColor(accentColor);
 441
 442             dashboardButton.setOnClickListener(v -> LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("com.farmerbb.taskbar.TOGGLE_DASHBOARD")));
 443         } else
 444             dashboardButton.setVisibility(View.GONE);
 445
 446         if(pref.getBoolean("button_back", false)) {
 447             navbarButtonsEnabled = true;
 448
 449             ImageView backButton = layout.findViewById(R.id.button_back);
 450             backButton.setColorFilter(accentColor);
 451             backButton.setVisibility(View.VISIBLE);
 452             backButton.setOnClickListener(v -> {
 453                 U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_BACK);
 454                 if(U.shouldCollapse(context, false))
 455                     hideTaskbar(true);
 456             });
 457
 458             backButton.setOnLongClickListener(v -> {
 459                 InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
 460                 imm.showInputMethodPicker();
 461
 462                 if(U.shouldCollapse(context, false))
 463                     hideTaskbar(true);
 464
 465                 return true;
 466             });
 467
 468             backButton.setOnGenericMotionListener((view13, motionEvent) -> {
 469                 if(motionEvent.getAction() == MotionEvent.ACTION_BUTTON_PRESS
 470                         && motionEvent.getButtonState() == MotionEvent.BUTTON_SECONDARY) {
 471                     InputMethodManager imm = (InputMethodManager) context.getSystemService(Context.INPUT_METHOD_SERVICE);
 472                     imm.showInputMethodPicker();
 473
 474                     if(U.shouldCollapse(context, false))
 475                         hideTaskbar(true);
 476                 }
 477                 return true;
 478             });
 479         }
 480
 481         if(pref.getBoolean("button_home", false)) {
 482             navbarButtonsEnabled = true;
 483
 484             ImageView homeButton = layout.findViewById(R.id.button_home);
 485             homeButton.setColorFilter(accentColor);
 486             homeButton.setVisibility(View.VISIBLE);
 487             homeButton.setOnClickListener(v -> {
 488                 U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_HOME);
 489                 if(U.shouldCollapse(context, false))
 490                     hideTaskbar(true);
 491             });
 492
 493             homeButton.setOnLongClickListener(v -> {
 494                 Intent voiceSearchIntent = new Intent(RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE);
 495                 voiceSearchIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 496
 497                 try {
 498                     context.startActivity(voiceSearchIntent);
 499                 } catch (ActivityNotFoundException e) { /* Gracefully fail */ }
 500
 501                 if(U.shouldCollapse(context, false))
 502                     hideTaskbar(true);
 503
 504                 return true;
 505             });
 506
 507             homeButton.setOnGenericMotionListener((view13, motionEvent) -> {
 508                 if(motionEvent.getAction() == MotionEvent.ACTION_BUTTON_PRESS
 509                         && motionEvent.getButtonState() == MotionEvent.BUTTON_SECONDARY) {
 510                     Intent voiceSearchIntent = new Intent(RecognizerIntent.ACTION_VOICE_SEARCH_HANDS_FREE);
 511                     voiceSearchIntent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
 512
 513                     try {
 514                         context.startActivity(voiceSearchIntent);
 515                     } catch (ActivityNotFoundException e) { /* Gracefully fail */ }
 516
 517                     if(U.shouldCollapse(context, false))
 518                         hideTaskbar(true);
 519                 }
 520                 return true;
 521             });
 522         }
 523
 524         if(pref.getBoolean("button_recents", false)) {
 525             navbarButtonsEnabled = true;
 526
 527             ImageView recentsButton = layout.findViewById(R.id.button_recents);
 528             recentsButton.setColorFilter(accentColor);
 529             recentsButton.setVisibility(View.VISIBLE);
 530             recentsButton.setOnClickListener(v -> {
 531                 U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_RECENTS);
 532                 if(U.shouldCollapse(context, false))
 533                     hideTaskbar(true);
 534             });
 535
 536             if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
 537                 recentsButton.setOnLongClickListener(v -> {
 538                     U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_TOGGLE_SPLIT_SCREEN);
 539                     if(U.shouldCollapse(context, false))
 540                         hideTaskbar(true);
 541
 542                     return true;
 543                 });
 544
 545                 recentsButton.setOnGenericMotionListener((view13, motionEvent) -> {
 546                     if(motionEvent.getAction() == MotionEvent.ACTION_BUTTON_PRESS
 547                             && motionEvent.getButtonState() == MotionEvent.BUTTON_SECONDARY) {
 548                         U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_TOGGLE_SPLIT_SCREEN);
 549                         if(U.shouldCollapse(context, false))
 550                             hideTaskbar(true);
 551                     }
 552                     return true;
 553                 });
 554             }
 555         }
 556
 557         if(!navbarButtonsEnabled)
 558             navbarButtons.setVisibility(View.GONE);
 559
 560         sysTrayEnabled = U.isSystemTrayEnabled(context);
 561
 562         if(sysTrayEnabled) {
 563             sysTrayLayout = (LinearLayout) LayoutInflater.from(context).inflate(R.layout.tb_system_tray, null);
 564
 565             FrameLayout.LayoutParams sysTrayParams = new FrameLayout.LayoutParams(
 566                     FrameLayout.LayoutParams.WRAP_CONTENT,
 567                     context.getResources().getDimensionPixelSize(R.dimen.tb_icon_size)
 568             );
 569
 570             if(layoutId == R.layout.tb_taskbar_right) {
 571                 time = sysTrayLayout.findViewById(R.id.time_left);
 572                 sysTrayParams.gravity = Gravity.START;
 573             } else {
 574                 time = sysTrayLayout.findViewById(R.id.time_right);
 575                 sysTrayParams.gravity = Gravity.END;
 576             }
 577
 578             time.setVisibility(View.VISIBLE);
 579             sysTrayLayout.setLayoutParams(sysTrayParams);
 580
 581             if(!U.isLibrary(context)) {
 582                 sysTrayLayout.setOnClickListener(v -> {
 583                     U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_NOTIFICATIONS);
 584                     if(U.shouldCollapse(context, false))
 585                         hideTaskbar(true);
 586                 });
 587
 588                 if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
 589                     sysTrayLayout.setOnLongClickListener(v -> {
 590                         U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_QUICK_SETTINGS);
 591                         if(U.shouldCollapse(context, false))
 592                             hideTaskbar(true);
 593
 594                         return true;
 595                     });
 596
 597                     sysTrayLayout.setOnGenericMotionListener((view, motionEvent) -> {
 598                         if(motionEvent.getAction() == MotionEvent.ACTION_BUTTON_PRESS
 599                                 && motionEvent.getButtonState() == MotionEvent.BUTTON_SECONDARY) {
 600                             U.sendAccessibilityAction(context, AccessibilityService.GLOBAL_ACTION_QUICK_SETTINGS);
 601                             if (U.shouldCollapse(context, false))
 602                                 hideTaskbar(true);
 603                         }
 604                         return true;
 605                     });
 606                 }
 607             }
 608
 609             sysTrayParentLayout = layout.findViewById(R.id.add_systray_here);
 610             sysTrayParentLayout.setVisibility(View.VISIBLE);
 611             sysTrayParentLayout.addView(sysTrayLayout);
 612
 613             TelephonyManager manager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
 614             manager.listen(listener, PhoneStateListener.LISTEN_SIGNAL_STRENGTHS);
 615         }
 616
 617         layout.setBackgroundColor(backgroundTint);
 618         layout.findViewById(R.id.divider).setBackgroundColor(accentColor);
 619         button.setTextColor(accentColor);
 620
 621         if(isFirstStart && FreeformHackHelper.getInstance().isInFreeformWorkspace())
 622             showTaskbar(false);
 623         else if(!pref.getBoolean("collapsed", false) && pref.getBoolean("taskbar_active", false))
 624             toggleTaskbar(false);
 625
 626         if(pref.getBoolean("auto_hide_navbar", false))
 627             U.showHideNavigationBar(context, false);
 628
 629         if(FreeformHackHelper.getInstance().isTouchAbsorberActive()) {
 630             lbm.sendBroadcast(new Intent("com.farmerbb.taskbar.FINISH_FREEFORM_ACTIVITY"));
 631
 632             new Handler().postDelayed(() -> U.startTouchAbsorberActivity(context), 500);
 633         }
 634
 635         lbm.unregisterReceiver(showReceiver);
 636         lbm.unregisterReceiver(hideReceiver);
 637         lbm.unregisterReceiver(tempShowReceiver);
 638         lbm.unregisterReceiver(tempHideReceiver);
 639         lbm.unregisterReceiver(startMenuAppearReceiver);
 640         lbm.unregisterReceiver(startMenuDisappearReceiver);
 641
 642         lbm.registerReceiver(showReceiver, new IntentFilter("com.farmerbb.taskbar.SHOW_TASKBAR"));
 643         lbm.registerReceiver(hideReceiver, new IntentFilter(TaskbarIntent.ACTION_HIDE_TASKBAR));
 644         lbm.registerReceiver(tempShowReceiver, new IntentFilter("com.farmerbb.taskbar.TEMP_SHOW_TASKBAR"));
 645         lbm.registerReceiver(tempHideReceiver, new IntentFilter("com.farmerbb.taskbar.TEMP_HIDE_TASKBAR"));
 646         lbm.registerReceiver(startMenuAppearReceiver, new IntentFilter("com.farmerbb.taskbar.START_MENU_APPEARING"));
 647         lbm.registerReceiver(startMenuDisappearReceiver, new IntentFilter("com.farmerbb.taskbar.START_MENU_DISAPPEARING"));
 648
 649         startRefreshingRecents();
 650
 651         host.addView(layout, params);
 652
 653         isFirstStart = false;
 654     }
 655
 656     private void startRefreshingRecents() {
 657         if(thread != null) thread.interrupt();
 658         stopThread2 = true;
 659
 660         SharedPreferences pref = U.getSharedPreferences(context);
 661         showHideAutomagically = pref.getBoolean("hide_when_keyboard_shown", false);
 662
 663         currentTaskbarIds.clear();
 664
 665         handler = new Handler();
 666         thread = new Thread(() -> {
 667             updateSystemTray();
 668             updateRecentApps(true);
 669
 670             if(!isRefreshingRecents) {
 671                 isRefreshingRecents = true;
 672
 673                 while(shouldRefreshRecents) {
 674                     SystemClock.sleep(refreshInterval);
 675                     updateSystemTray();
 676                     updateRecentApps(false);
 677
 678                     if(showHideAutomagically && !positionIsVertical && !MenuHelper.getInstance().isStartMenuOpen())
 679                         handler.post(() -> {
 680                             if(layout != null) {
 681                                 int[] location = new int[2];
 682                                 layout.getLocationOnScreen(location);
 683
 684                                 if(location[1] != 0) {
 685                                     if(location[1] > currentTaskbarPosition) {
 686                                         currentTaskbarPosition = location[1];
 687                                     } else if(location[1] < currentTaskbarPosition) {
 688                                         if(currentTaskbarPosition - location[1] == getNavBarSize())
 689                                             currentTaskbarPosition = location[1];
 690                                         else if(!startThread2) {
 691                                             startThread2 = true;
 692                                             tempHideTaskbar(true);
 693                                         }
 694                                     }
 695                                 }
 696                             }
 697                         });
 698                 }
 699
 700                 isRefreshingRecents = false;
 701             }
 702         });
 703
 704         thread.start();
 705     }
 706
 707     @SuppressWarnings("Convert2streamapi")
 708     @TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
 709     private void updateRecentApps(final boolean firstRefresh) {
 710         if(isScreenOff()) return;
 711
 712         SharedPreferences pref = U.getSharedPreferences(context);
 713         final PackageManager pm = context.getPackageManager();
 714         final List<AppEntry> entries = new ArrayList<>();
 715         List<LauncherActivityInfo> launcherAppCache = new ArrayList<>();
 716         int maxNumOfEntries = U.getMaxNumOfEntries(context);
 717         int realNumOfPinnedApps = 0;
 718         boolean fullLength = pref.getBoolean("full_length", context.getResources().getBoolean(R.bool.tb_def_full_length));
 719
 720         PinnedBlockedApps pba = PinnedBlockedApps.getInstance(context);
 721         List<AppEntry> pinnedApps = pba.getPinnedApps();
 722         List<AppEntry> blockedApps = pba.getBlockedApps();
 723         List<String> applicationIdsToRemove = new ArrayList<>();
 724
 725         // Filter out anything on the pinned/blocked apps lists
 726         if(pinnedApps.size() > 0) {
 727             UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
 728             LauncherApps launcherApps = (LauncherApps) context.getSystemService(Context.LAUNCHER_APPS_SERVICE);
 729
 730             for(AppEntry entry : pinnedApps) {
 731                 boolean packageEnabled = launcherApps.isPackageEnabled(entry.getPackageName(),
 732                         userManager.getUserForSerialNumber(entry.getUserId(context)));
 733
 734                 if(packageEnabled)
 735                     entries.add(entry);
 736                 else
 737                     realNumOfPinnedApps--;
 738
 739                 applicationIdsToRemove.add(entry.getPackageName());
 740             }
 741
 742             realNumOfPinnedApps = realNumOfPinnedApps + pinnedApps.size();
 743         }
 744
 745         if(blockedApps.size() > 0) {
 746             for(AppEntry entry : blockedApps) {
 747                 applicationIdsToRemove.add(entry.getPackageName());
 748             }
 749         }
 750
 751         // Get list of all recently used apps
 752         List<AppEntry> usageStatsList = realNumOfPinnedApps < maxNumOfEntries ? getAppEntries() : new ArrayList<>();
 753         if(usageStatsList.size() > 0 || realNumOfPinnedApps > 0 || fullLength) {
 754             if(realNumOfPinnedApps < maxNumOfEntries) {
 755                 List<AppEntry> usageStatsList2 = new ArrayList<>();
 756                 List<AppEntry> usageStatsList3 = new ArrayList<>();
 757                 List<AppEntry> usageStatsList4 = new ArrayList<>();
 758                 List<AppEntry> usageStatsList5 = new ArrayList<>();
 759                 List<AppEntry> usageStatsList6;
 760
 761                 Intent homeIntent = new Intent(Intent.ACTION_MAIN);
 762                 homeIntent.addCategory(Intent.CATEGORY_HOME);
 763                 ResolveInfo defaultLauncher = pm.resolveActivity(homeIntent, PackageManager.MATCH_DEFAULT_ONLY);
 764
 765                 // Filter out apps without a launcher intent
 766                 // Also filter out the current launcher, and Taskbar itself
 767                 for(AppEntry packageInfo : usageStatsList) {
 768                     if(hasLauncherIntent(packageInfo.getPackageName())
 769                             && !packageInfo.getPackageName().contains(BuildConfig.BASE_APPLICATION_ID)
 770                             && !packageInfo.getPackageName().equals(defaultLauncher.activityInfo.packageName))
 771                         usageStatsList2.add(packageInfo);
 772                 }
 773
 774                 // Filter out apps that don't fall within our current search interval
 775                 for(AppEntry stats : usageStatsList2) {
 776                     if(stats.getLastTimeUsed() > searchInterval || runningAppsOnly)
 777                         usageStatsList3.add(stats);
 778                 }
 779
 780                 // Sort apps by either most recently used, or most time used
 781                 if(!runningAppsOnly && sortOrder.contains("most_used")) {
 782                     Collections.sort(usageStatsList3, (us1, us2) -> Long.compare(us2.getTotalTimeInForeground(), us1.getTotalTimeInForeground()));
 783                 } else {
 784                     Collections.sort(usageStatsList3, (us1, us2) -> Long.compare(us2.getLastTimeUsed(), us1.getLastTimeUsed()));
 785                 }
 786
 787                 // Filter out any duplicate entries
 788                 List<String> applicationIds = new ArrayList<>();
 789                 for(AppEntry stats : usageStatsList3) {
 790                     if(!applicationIds.contains(stats.getPackageName())) {
 791                         usageStatsList4.add(stats);
 792                         applicationIds.add(stats.getPackageName());
 793                     }
 794                 }
 795
 796                 // Filter out the currently running foreground app, if requested by the user
 797                 if(pref.getBoolean("hide_foreground", false)) {
 798                     UsageStatsManager mUsageStatsManager = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);
 799                     UsageEvents events = mUsageStatsManager.queryEvents(searchInterval, System.currentTimeMillis());
 800                     UsageEvents.Event eventCache = new UsageEvents.Event();
 801                     String currentForegroundApp = null;
 802
 803                     while(events.hasNextEvent()) {
 804                         events.getNextEvent(eventCache);
 805
 806                         if(eventCache.getEventType() == UsageEvents.Event.MOVE_TO_FOREGROUND) {
 807                             if(!(eventCache.getPackageName().contains(BuildConfig.BASE_APPLICATION_ID)
 808                                     && !eventCache.getClassName().equals(MainActivity.class.getCanonicalName())
 809                                     && !eventCache.getClassName().equals(HomeActivity.class.getCanonicalName())
 810                                     && !eventCache.getClassName().equals(HomeActivityDelegate.class.getCanonicalName())
 811                                     && !eventCache.getClassName().equals(SecondaryHomeActivity.class.getCanonicalName())
 812                                     && !eventCache.getClassName().equals(InvisibleActivityFreeform.class.getCanonicalName())))
 813                                 currentForegroundApp = eventCache.getPackageName();
 814                         }
 815                     }
 816
 817                     if(!applicationIdsToRemove.contains(currentForegroundApp))
 818                         applicationIdsToRemove.add(currentForegroundApp);
 819                 }
 820
 821                 for(AppEntry stats : usageStatsList4) {
 822                     if(!applicationIdsToRemove.contains(stats.getPackageName())) {
 823                         usageStatsList5.add(stats);
 824                     }
 825                 }
 826
 827                 // Truncate list to a maximum length
 828                 if(usageStatsList5.size() > maxNumOfEntries)
 829                     usageStatsList6 = usageStatsList5.subList(0, maxNumOfEntries);
 830                 else
 831                     usageStatsList6 = usageStatsList5;
 832
 833                 // Determine if we need to reverse the order
 834                 boolean needToReverseOrder;
 835                 switch(U.getTaskbarPosition(context)) {
 836                     case "bottom_right":
 837                     case "top_right":
 838                         needToReverseOrder = sortOrder.contains("false");
 839                         break;
 840                     default:
 841                         needToReverseOrder = sortOrder.contains("true");
 842                         break;
 843                 }
 844
 845                 if(needToReverseOrder) {
 846                     Collections.reverse(usageStatsList6);
 847                 }
 848
 849                 // Generate the AppEntries for the recent apps list
 850                 int number = usageStatsList6.size() == maxNumOfEntries
 851                         ? usageStatsList6.size() - realNumOfPinnedApps
 852                         : usageStatsList6.size();
 853
 854                 UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
 855                 LauncherApps launcherApps = (LauncherApps) context.getSystemService(Context.LAUNCHER_APPS_SERVICE);
 856
 857                 final List<UserHandle> userHandles = userManager.getUserProfiles();
 858
 859                 for(int i = 0; i < number; i++) {
 860                     for(UserHandle handle : userHandles) {
 861                         String packageName = usageStatsList6.get(i).getPackageName();
 862                         long lastTimeUsed = usageStatsList6.get(i).getLastTimeUsed();
 863                         List<LauncherActivityInfo> list = launcherApps.getActivityList(packageName, handle);
 864                         if(!list.isEmpty()) {
 865                             // Google App workaround
 866                             if(!packageName.equals("com.google.android.googlequicksearchbox"))
 867                                 launcherAppCache.add(list.get(0));
 868                             else {
 869                                 boolean added = false;
 870                                 for(LauncherActivityInfo info : list) {
 871                                     if(info.getName().equals("com.google.android.googlequicksearchbox.SearchActivity")) {
 872                                         launcherAppCache.add(info);
 873                                         added = true;
 874                                     }
 875                                 }
 876
 877                                 if(!added) launcherAppCache.add(list.get(0));
 878                             }
 879
 880                             AppEntry newEntry = new AppEntry(
 881                                     packageName,
 882                                     null,
 883                                     null,
 884                                     null,
 885                                     false
 886                             );
 887
 888                             newEntry.setUserId(userManager.getSerialNumberForUser(handle));
 889                             newEntry.setLastTimeUsed(lastTimeUsed);
 890                             entries.add(newEntry);
 891
 892                             break;
 893                         }
 894                     }
 895                 }
 896             }
 897
 898             while(entries.size() > maxNumOfEntries) {
 899                 try {
 900                     entries.remove(entries.size() - 1);
 901                     launcherAppCache.remove(launcherAppCache.size() - 1);
 902                 } catch (ArrayIndexOutOfBoundsException e) { /* Gracefully fail */ }
 903             }
 904
 905             // Determine if we need to reverse the order again
 906             if(U.getTaskbarPosition(context).contains("vertical")) {
 907                 Collections.reverse(entries);
 908                 Collections.reverse(launcherAppCache);
 909             }
 910
 911             // Now that we've generated the list of apps,
 912             // we need to determine if we need to redraw the Taskbar or not
 913             boolean shouldRedrawTaskbar = firstRefresh;
 914
 915             List<String> finalApplicationIds = new ArrayList<>();
 916             for(AppEntry entry : entries) {
 917                 finalApplicationIds.add(entry.getPackageName());
 918             }
 919
 920             if(finalApplicationIds.size() != currentTaskbarIds.size()
 921                     || numOfPinnedApps != realNumOfPinnedApps)
 922                 shouldRedrawTaskbar = true;
 923             else {
 924                 for(int i = 0; i < finalApplicationIds.size(); i++) {
 925                     if(!finalApplicationIds.get(i).equals(currentTaskbarIds.get(i))) {
 926                         shouldRedrawTaskbar = true;
 927                         break;
 928                     }
 929                 }
 930             }
 931
 932             if(shouldRedrawTaskbar) {
 933                 currentTaskbarIds = finalApplicationIds;
 934                 numOfPinnedApps = realNumOfPinnedApps;
 935
 936                 UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
 937
 938                 int launcherAppCachePos = -1;
 939                 for(int i = 0; i < entries.size(); i++) {
 940                     if(entries.get(i).getComponentName() == null) {
 941                         launcherAppCachePos++;
 942                         LauncherActivityInfo appInfo = launcherAppCache.get(launcherAppCachePos);
 943                         String packageName = entries.get(i).getPackageName();
 944                         long lastTimeUsed = entries.get(i).getLastTimeUsed();
 945
 946                         entries.remove(i);
 947
 948                         AppEntry newEntry = new AppEntry(
 949                                 packageName,
 950                                 appInfo.getComponentName().flattenToString(),
 951                                 appInfo.getLabel().toString(),
 952                                 IconCache.getInstance(context).getIcon(context, pm, appInfo),
 953                                 false);
 954
 955                         newEntry.setUserId(userManager.getSerialNumberForUser(appInfo.getUser()));
 956                         newEntry.setLastTimeUsed(lastTimeUsed);
 957                         entries.add(i, newEntry);
 958                     }
 959                 }
 960
 961                 final int numOfEntries = Math.min(entries.size(), maxNumOfEntries);
 962
 963                 handler.post(() -> {
 964                     if(numOfEntries > 0 || fullLength) {
 965                         ViewGroup.LayoutParams params = scrollView.getLayoutParams();
 966                         DisplayInfo display = U.getDisplayInfo(context, true);
 967                         int recentsSize = context.getResources().getDimensionPixelSize(R.dimen.tb_icon_size) * numOfEntries;
 968                         float maxRecentsSize = fullLength ? Float.MAX_VALUE : recentsSize;
 969
 970                         if(U.getTaskbarPosition(context).contains("vertical")) {
 971                             int maxScreenSize = Math.max(0, display.height
 972                                     - U.getStatusBarHeight(context)
 973                                     - U.getBaseTaskbarSize(context));
 974
 975                             params.height = (int) Math.min(maxRecentsSize, maxScreenSize)
 976                                     + context.getResources().getDimensionPixelSize(R.dimen.tb_divider_size);
 977
 978                             if(fullLength) {
 979                                 try {
 980                                     Space whitespaceTop = layout.findViewById(R.id.whitespace_top);
 981                                     Space whitespaceBottom = layout.findViewById(R.id.whitespace_bottom);
 982                                     int height = maxScreenSize - recentsSize;
 983
 984                                     if(pref.getBoolean("centered_icons", false)) {
 985                                         ViewGroup.LayoutParams topParams = whitespaceTop.getLayoutParams();
 986                                         topParams.height = height / 2;
 987                                         whitespaceTop.setLayoutParams(topParams);
 988
 989                                         ViewGroup.LayoutParams bottomParams = whitespaceBottom.getLayoutParams();
 990                                         bottomParams.height = height / 2;
 991                                         whitespaceBottom.setLayoutParams(bottomParams);
 992                                     } else if(U.getTaskbarPosition(context).contains("bottom")) {
 993                                         ViewGroup.LayoutParams topParams = whitespaceTop.getLayoutParams();
 994                                         topParams.height = height;
 995                                         whitespaceTop.setLayoutParams(topParams);
 996                                     } else {
 997                                         ViewGroup.LayoutParams bottomParams = whitespaceBottom.getLayoutParams();
 998                                         bottomParams.height = height;
 999                                         whitespaceBottom.setLayoutParams(bottomParams);
1000                                     }
1001                                 } catch (NullPointerException e) { /* Gracefully fail */ }
1002                             }
1003                         } else {
1004                             int maxScreenSize = Math.max(0, display.width - U.getBaseTaskbarSize(context));
1005
1006                             params.width = (int) Math.min(maxRecentsSize, maxScreenSize)
1007                                     + context.getResources().getDimensionPixelSize(R.dimen.tb_divider_size);
1008
1009                             if(fullLength) {
1010                                 try {
1011                                     Space whitespaceLeft = layout.findViewById(R.id.whitespace_left);
1012                                     Space whitespaceRight = layout.findViewById(R.id.whitespace_right);
1013                                     int width = maxScreenSize - recentsSize;
1014
1015                                     if(pref.getBoolean("centered_icons", false)) {
1016                                         ViewGroup.LayoutParams leftParams = whitespaceLeft.getLayoutParams();
1017                                         leftParams.width = width / 2;
1018                                         whitespaceLeft.setLayoutParams(leftParams);
1019
1020                                         ViewGroup.LayoutParams rightParams = whitespaceRight.getLayoutParams();
1021                                         rightParams.width = width / 2;
1022                                         whitespaceRight.setLayoutParams(rightParams);
1023                                     } else if(U.getTaskbarPosition(context).contains("right")) {
1024                                         ViewGroup.LayoutParams leftParams = whitespaceLeft.getLayoutParams();
1025                                         leftParams.width = width;
1026                                         whitespaceLeft.setLayoutParams(leftParams);
1027                                     } else {
1028                                         ViewGroup.LayoutParams rightParams = whitespaceRight.getLayoutParams();
1029                                         rightParams.width = width;
1030                                         whitespaceRight.setLayoutParams(rightParams);
1031                                     }
1032                                 } catch (NullPointerException e) { /* Gracefully fail */ }
1033                             }
1034                         }
1035
1036                         scrollView.setLayoutParams(params);
1037
1038                         taskbar.removeAllViews();
1039                         for(int i = 0; i < entries.size(); i++) {
1040                             taskbar.addView(getView(entries, i));
1041                         }
1042
1043                         if(runningAppsOnly)
1044                             updateRunningAppIndicators(pinnedApps, usageStatsList, entries);
1045
1046                         isShowingRecents = true;
1047                         if(shouldRefreshRecents && scrollView.getVisibility() != View.VISIBLE) {
1048                             if(firstRefresh)
1049                                 scrollView.setVisibility(View.INVISIBLE);
1050                             else
1051                                 scrollView.setVisibility(View.VISIBLE);
1052                         }
1053
1054                         if(firstRefresh && scrollView.getVisibility() != View.VISIBLE)
1055                             new Handler().post(() -> {
1056                                 switch(U.getTaskbarPosition(context)) {
1057                                     case "bottom_left":
1058                                     case "bottom_right":
1059                                     case "top_left":
1060                                     case "top_right":
1061                                         if(sortOrder.contains("false"))
1062                                             scrollView.scrollTo(0, 0);
1063                                         else if(sortOrder.contains("true"))
1064                                             scrollView.scrollTo(taskbar.getWidth(), taskbar.getHeight());
1065                                         break;
1066                                     case "bottom_vertical_left":
1067                                     case "bottom_vertical_right":
1068                                     case "top_vertical_left":
1069                                     case "top_vertical_right":
1070                                         if(sortOrder.contains("false"))
1071                                             scrollView.scrollTo(taskbar.getWidth(), taskbar.getHeight());
1072                                         else if(sortOrder.contains("true"))
1073                                             scrollView.scrollTo(0, 0);
1074                                         break;
1075                                 }
1076
1077                                 if(shouldRefreshRecents) {
1078                                     scrollView.setVisibility(View.VISIBLE);
1079                                 }
1080                             });
1081                     } else {
1082                         isShowingRecents = false;
1083                         scrollView.setVisibility(View.GONE);
1084                     }
1085                 });
1086             } else if(runningAppsOnly)
1087                 handler.post(() -> updateRunningAppIndicators(pinnedApps, usageStatsList, entries));
1088         } else if(firstRefresh || currentTaskbarIds.size() > 0) {
1089             currentTaskbarIds.clear();
1090             handler.post(() -> {
1091                 isShowingRecents = false;
1092                 scrollView.setVisibility(View.GONE);
1093             });
1094         }
1095     }
1096
1097     private void updateRunningAppIndicators(List<AppEntry> pinnedApps, List<AppEntry> usageStatsList, List<AppEntry> entries) {
1098         if(taskbar.getChildCount() != entries.size())
1099             return;
1100
1101         List<String> pinnedPackageList = new ArrayList<>();
1102         List<String> runningPackageList = new ArrayList<>();
1103
1104         for(AppEntry entry : pinnedApps)
1105             pinnedPackageList.add(entry.getPackageName());
1106
1107         for(AppEntry entry : usageStatsList)
1108             runningPackageList.add(entry.getPackageName());
1109
1110         for(int i = 0; i < taskbar.getChildCount(); i++) {
1111             View convertView = taskbar.getChildAt(i);
1112             String packageName = entries.get(i).getPackageName();
1113
1114             ImageView runningAppIndicator = convertView.findViewById(R.id.running_app_indicator);
1115             if(pinnedPackageList.contains(packageName) && !runningPackageList.contains(packageName))
1116                 runningAppIndicator.setVisibility(View.GONE);
1117             else {
1118                 runningAppIndicator.setVisibility(View.VISIBLE);
1119                 runningAppIndicator.setColorFilter(U.getAccentColor(context));
1120             }
1121         }
1122     }
1123
1124     private void toggleTaskbar(boolean userInitiated) {
1125         if(userInitiated && Build.BRAND.equalsIgnoreCase("essential")) {
1126             SharedPreferences pref = U.getSharedPreferences(context);
1127             if(!pref.getBoolean("grip_rejection_toast_shown", false)) {
1128                 U.showToastLong(context, R.string.tb_essential_phone_grip_rejection);
1129                 pref.edit().putBoolean("grip_rejection_toast_shown", true).apply();
1130             }
1131         }
1132
1133         if(startButton.getVisibility() == View.GONE)
1134             showTaskbar(true);
1135         else
1136             hideTaskbar(true);
1137     }
1138
1139     private void showTaskbar(boolean clearVariables) {
1140         if(clearVariables) {
1141             taskbarShownTemporarily = false;
1142             taskbarHiddenTemporarily = false;
1143         }
1144
1145         if(startButton.getVisibility() == View.GONE) {
1146             startButton.setVisibility(View.VISIBLE);
1147             space.setVisibility(View.VISIBLE);
1148
1149             if(dashboardEnabled)
1150                 dashboardButton.setVisibility(View.VISIBLE);
1151
1152             if(navbarButtonsEnabled)
1153                 navbarButtons.setVisibility(View.VISIBLE);
1154
1155             if(isShowingRecents && scrollView.getVisibility() == View.GONE)
1156                 scrollView.setVisibility(View.INVISIBLE);
1157
1158             if(sysTrayEnabled)
1159                 sysTrayParentLayout.setVisibility(View.VISIBLE);
1160
1161             shouldRefreshRecents = true;
1162             startRefreshingRecents();
1163
1164             SharedPreferences pref = U.getSharedPreferences(context);
1165             pref.edit().putBoolean("collapsed", true).apply();
1166
1167             updateButton(false);
1168
1169             new Handler().post(() -> LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("com.farmerbb.taskbar.SHOW_START_MENU_SPACE")));
1170         }
1171     }
1172
1173     private void hideTaskbar(boolean clearVariables) {
1174         if(clearVariables) {
1175             taskbarShownTemporarily = false;
1176             taskbarHiddenTemporarily = false;
1177         }
1178
1179         if(startButton.getVisibility() == View.VISIBLE) {
1180             startButton.setVisibility(View.GONE);
1181             space.setVisibility(View.GONE);
1182
1183             if(dashboardEnabled)
1184                 dashboardButton.setVisibility(View.GONE);
1185
1186             if(navbarButtonsEnabled)
1187                 navbarButtons.setVisibility(View.GONE);
1188
1189             if(isShowingRecents)
1190                 scrollView.setVisibility(View.GONE);
1191
1192             if(sysTrayEnabled)
1193                 sysTrayParentLayout.setVisibility(View.GONE);
1194
1195             shouldRefreshRecents = false;
1196             if(thread != null) thread.interrupt();
1197
1198             SharedPreferences pref = U.getSharedPreferences(context);
1199             pref.edit().putBoolean("collapsed", false).apply();
1200
1201             updateButton(true);
1202
1203             if(clearVariables) {
1204                 LocalBroadcastManager
1205                         .getInstance(context)
1206                         .sendBroadcast(new Intent(TaskbarIntent.ACTION_HIDE_START_MENU));
1207                 LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("com.farmerbb.taskbar.HIDE_DASHBOARD"));
1208             }
1209
1210             new Handler().post(() -> LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent("com.farmerbb.taskbar.HIDE_START_MENU_SPACE")));
1211         }
1212     }
1213
1214     private void tempShowTaskbar() {
1215         if(!taskbarHiddenTemporarily) {
1216             SharedPreferences pref = U.getSharedPreferences(context);
1217             if(!pref.getBoolean("collapsed", false)) taskbarShownTemporarily = true;
1218         }
1219
1220         showTaskbar(false);
1221
1222         if(taskbarHiddenTemporarily)
1223             taskbarHiddenTemporarily = false;
1224     }
1225
1226     private void tempHideTaskbar(boolean monitorPositionChanges) {
1227         if(!taskbarShownTemporarily) {
1228             SharedPreferences pref = U.getSharedPreferences(context);
1229             if(pref.getBoolean("collapsed", false)) taskbarHiddenTemporarily = true;
1230         }
1231
1232         hideTaskbar(false);
1233
1234         if(taskbarShownTemporarily)
1235             taskbarShownTemporarily = false;
1236
1237         if(monitorPositionChanges && showHideAutomagically && !positionIsVertical) {
1238             if(thread2 != null) thread2.interrupt();
1239
1240             handler2 = new Handler();
1241             thread2 = new Thread(() -> {
1242                 stopThread2 = false;
1243
1244                 while(!stopThread2) {
1245                     SystemClock.sleep(refreshInterval);
1246
1247                     handler2.post(() -> stopThread2 = checkPositionChange());
1248                 }
1249
1250                 startThread2 = false;
1251             });
1252
1253             thread2.start();
1254         }
1255     }
1256
1257     private boolean checkPositionChange() {
1258         if(!isScreenOff() && layout != null) {
1259             int[] location = new int[2];
1260             layout.getLocationOnScreen(location);
1261
1262             if(location[1] == 0) {
1263                 return true;
1264             } else {
1265                 if(location[1] > currentTaskbarPosition) {
1266                     currentTaskbarPosition = location[1];
1267                     if(taskbarHiddenTemporarily) {
1268                         tempShowTaskbar();
1269                         return true;
1270                     }
1271                 } else if(location[1] == currentTaskbarPosition && taskbarHiddenTemporarily) {
1272                     tempShowTaskbar();
1273                     return true;
1274                 } else if(location[1] < currentTaskbarPosition
1275                         && currentTaskbarPosition - location[1] == getNavBarSize()) {
1276                     currentTaskbarPosition = location[1];
1277                 }
1278             }
1279         }
1280
1281         return false;
1282     }
1283
1284     private int getNavBarSize() {
1285         Point size = new Point();
1286         Point realSize = new Point();
1287
1288         WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
1289         Display display = wm.getDefaultDisplay();
1290         display.getSize(size);
1291         display.getRealSize(realSize);
1292
1293         return realSize.y - size.y;
1294     }
1295
1296     @Override
1297     public void onDestroyHost(UIHost host) {
1298         shouldRefreshRecents = false;
1299
1300         if(layout != null)
1301             try {
1302                 host.removeView(layout);
1303             } catch (IllegalArgumentException e) { /* Gracefully fail */ }
1304
1305         SharedPreferences pref = U.getSharedPreferences(context);
1306         if(pref.getBoolean("skip_auto_hide_navbar", false)) {
1307             pref.edit().remove("skip_auto_hide_navbar").apply();
1308         } else if(pref.getBoolean("auto_hide_navbar", false))
1309             U.showHideNavigationBar(context, true);
1310
1311         LocalBroadcastManager lbm = LocalBroadcastManager.getInstance(context);
1312
1313         lbm.unregisterReceiver(showReceiver);
1314         lbm.unregisterReceiver(hideReceiver);
1315         lbm.unregisterReceiver(tempShowReceiver);
1316         lbm.unregisterReceiver(tempHideReceiver);
1317         lbm.unregisterReceiver(startMenuAppearReceiver);
1318         lbm.unregisterReceiver(startMenuDisappearReceiver);
1319
1320         if(sysTrayEnabled) {
1321             TelephonyManager manager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
1322             manager.listen(listener, PhoneStateListener.LISTEN_NONE);
1323         }
1324
1325         isFirstStart = true;
1326     }
1327
1328     private void openContextMenu() {
1329         SharedPreferences pref = U.getSharedPreferences(context);
1330
1331         Bundle args = new Bundle();
1332         args.putBoolean("dont_show_quit",
1333                 LauncherHelper.getInstance().isOnHomeScreen()
1334                         && !pref.getBoolean("taskbar_active", false));
1335         args.putBoolean("is_start_button", true);
1336
1337         U.startContextMenuActivity(context, args);
1338     }
1339
1340     private void updateButton(boolean isCollapsed) {
1341         SharedPreferences pref = U.getSharedPreferences(context);
1342         boolean hide = pref.getBoolean("invisible_button", false);
1343
1344         if(button != null) button.setText(context.getString(isCollapsed ? R.string.tb_right_arrow : R.string.tb_left_arrow));
1345         if(layout != null) layout.setAlpha(isCollapsed && hide ? 0 : 1);
1346     }
1347
1348     @TargetApi(Build.VERSION_CODES.M)
1349     @Override
1350     public void onRecreateHost(UIHost host) {
1351         if(layout != null) {
1352             try {
1353                 host.removeView(layout);
1354             } catch (IllegalArgumentException e) { /* Gracefully fail */ }
1355
1356             currentTaskbarPosition = 0;
1357
1358             if(U.canDrawOverlays(context))
1359                 drawTaskbar(host);
1360             else {
1361                 SharedPreferences pref = U.getSharedPreferences(context);
1362                 pref.edit().putBoolean("taskbar_active", false).apply();
1363
1364                 host.terminate();
1365             }
1366         }
1367     }
1368
1369     private View getView(List<AppEntry> list, int position) {
1370         View convertView = View.inflate(context, R.layout.tb_icon, null);
1371
1372         final AppEntry entry = list.get(position);
1373         final SharedPreferences pref = U.getSharedPreferences(context);
1374
1375         ImageView imageView = convertView.findViewById(R.id.icon);
1376         ImageView imageView2 = convertView.findViewById(R.id.shortcut_icon);
1377         imageView.setImageDrawable(entry.getIcon(context));
1378         imageView2.setBackgroundColor(U.getAccentColor(context));
1379
1380         String taskbarPosition = U.getTaskbarPosition(context);
1381         if(pref.getBoolean("shortcut_icon", true)) {
1382             boolean shouldShowShortcutIcon;
1383             if(taskbarPosition.contains("vertical"))
1384                 shouldShowShortcutIcon = position >= list.size() - numOfPinnedApps;
1385             else
1386                 shouldShowShortcutIcon = position < numOfPinnedApps;
1387
1388             if(shouldShowShortcutIcon) imageView2.setVisibility(View.VISIBLE);
1389         }
1390
1391         if(taskbarPosition.equals("bottom_right") || taskbarPosition.equals("top_right")) {
1392             imageView.setRotationY(180);
1393             imageView2.setRotationY(180);
1394         }
1395
1396         FrameLayout layout = convertView.findViewById(R.id.entry);
1397         layout.setOnClickListener(view -> U.launchApp(
1398                 context,
1399                 entry,
1400                 null,
1401                 true,
1402                 false,
1403                 view
1404         ));
1405
1406         layout.setOnLongClickListener(view -> {
1407             int[] location = new int[2];
1408             view.getLocationOnScreen(location);
1409             openContextMenu(entry, location);
1410             return true;
1411         });
1412
1413         layout.setOnGenericMotionListener((view, motionEvent) -> {
1414             int action = motionEvent.getAction();
1415
1416             if(action == MotionEvent.ACTION_BUTTON_PRESS
1417                     && motionEvent.getButtonState() == MotionEvent.BUTTON_SECONDARY) {
1418                 int[] location = new int[2];
1419                 view.getLocationOnScreen(location);
1420                 openContextMenu(entry, location);
1421             }
1422
1423             if(action == MotionEvent.ACTION_SCROLL && pref.getBoolean("visual_feedback", true))
1424                 view.setBackgroundColor(0);
1425
1426             return false;
1427         });
1428
1429         if(pref.getBoolean("visual_feedback", true)) {
1430             layout.setOnHoverListener((v, event) -> {
1431                 if(event.getAction() == MotionEvent.ACTION_HOVER_ENTER) {
1432                     int accentColor = U.getAccentColor(context);
1433                     accentColor = ColorUtils.setAlphaComponent(accentColor, Color.alpha(accentColor) / 2);
1434                     v.setBackgroundColor(accentColor);
1435                 }
1436
1437                 if(event.getAction() == MotionEvent.ACTION_HOVER_EXIT)
1438                     v.setBackgroundColor(0);
1439
1440                 if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.N)
1441                     v.setPointerIcon(PointerIcon.getSystemIcon(context, PointerIcon.TYPE_DEFAULT));
1442
1443                 return false;
1444             });
1445
1446             layout.setOnTouchListener((v, event) -> {
1447                 v.setAlpha(event.getAction() == MotionEvent.ACTION_DOWN || event.getAction() == MotionEvent.ACTION_MOVE ? 0.5f : 1);
1448                 return false;
1449             });
1450         }
1451
1452         return convertView;
1453     }
1454
1455     private void openContextMenu(AppEntry entry, int[] location) {
1456         Bundle args = new Bundle();
1457         args.putSerializable("app_entry", entry);
1458         args.putInt("x", location[0]);
1459         args.putInt("y", location[1]);
1460
1461         U.startContextMenuActivity(context, args);
1462     }
1463
1464     private List<AppEntry> getAppEntries() {
1465         SharedPreferences pref = U.getSharedPreferences(context);
1466         if(runningAppsOnly)
1467             return getAppEntriesUsingActivityManager(Integer.parseInt(pref.getString("max_num_of_recents", "10")));
1468         else
1469             return getAppEntriesUsingUsageStats();
1470     }
1471
1472     @SuppressWarnings("deprecation")
1473     @TargetApi(Build.VERSION_CODES.M)
1474     private List<AppEntry> getAppEntriesUsingActivityManager(int maxNum) {
1475         ActivityManager mActivityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
1476         List<ActivityManager.RecentTaskInfo> usageStatsList = mActivityManager.getRecentTasks(maxNum, 0);
1477         List<AppEntry> entries = new ArrayList<>();
1478
1479         for(int i = 0; i < usageStatsList.size(); i++) {
1480             ActivityManager.RecentTaskInfo recentTaskInfo = usageStatsList.get(i);
1481             if(recentTaskInfo.id != -1) {
1482                 String packageName = recentTaskInfo.baseActivity.getPackageName();
1483                 AppEntry newEntry = new AppEntry(
1484                         packageName,
1485                         null,
1486                         null,
1487                         null,
1488                         false
1489                 );
1490
1491                 try {
1492                     Field field = ActivityManager.RecentTaskInfo.class.getField("firstActiveTime");
1493                     newEntry.setLastTimeUsed(field.getLong(recentTaskInfo));
1494                 } catch (Exception e) {
1495                     newEntry.setLastTimeUsed(i);
1496                 }
1497
1498                 entries.add(newEntry);
1499             }
1500         }
1501
1502         return entries;
1503     }
1504
1505     @TargetApi(Build.VERSION_CODES.LOLLIPOP_MR1)
1506     private List<AppEntry> getAppEntriesUsingUsageStats() {
1507         UsageStatsManager mUsageStatsManager = (UsageStatsManager) context.getSystemService(Context.USAGE_STATS_SERVICE);
1508         List<UsageStats> usageStatsList = mUsageStatsManager.queryUsageStats(UsageStatsManager.INTERVAL_BEST, searchInterval, System.currentTimeMillis());
1509         List<AppEntry> entries = new ArrayList<>();
1510
1511         for(UsageStats usageStats : usageStatsList) {
1512             AppEntry newEntry = new AppEntry(
1513                     usageStats.getPackageName(),
1514                     null,
1515                     null,
1516                     null,
1517                     false
1518             );
1519
1520             newEntry.setTotalTimeInForeground(usageStats.getTotalTimeInForeground());
1521             newEntry.setLastTimeUsed(usageStats.getLastTimeUsed());
1522             entries.add(newEntry);
1523         }
1524
1525         return entries;
1526     }
1527
1528     private boolean hasLauncherIntent(String packageName) {
1529         Intent intentToResolve = new Intent(Intent.ACTION_MAIN);
1530         intentToResolve.addCategory(Intent.CATEGORY_LAUNCHER);
1531         intentToResolve.setPackage(packageName);
1532
1533         List<ResolveInfo> ris = context.getPackageManager().queryIntentActivities(intentToResolve, 0);
1534         return ris != null && ris.size() > 0;
1535     }
1536
1537     private boolean isScreenOff() {
1538         if(U.isChromeOs(context))
1539             return false;
1540
1541         PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
1542         return !pm.isInteractive();
1543     }
1544
1545     private void updateSystemTray() {
1546         if(!sysTrayEnabled || isScreenOff()) return;
1547
1548         handler.post(() -> {
1549             ImageView battery = sysTrayLayout.findViewById(R.id.battery);
1550             battery.setImageDrawable(getBatteryDrawable());
1551
1552             ImageView wifi = sysTrayLayout.findViewById(R.id.wifi);
1553             wifi.setImageDrawable(getWifiDrawable());
1554
1555             ImageView bluetooth = sysTrayLayout.findViewById(R.id.bluetooth);
1556             bluetooth.setImageDrawable(getBluetoothDrawable());
1557
1558             ImageView cellular = sysTrayLayout.findViewById(R.id.cellular);
1559             cellular.setImageDrawable(getCellularDrawable());
1560
1561             time.setText(context.getString(R.string.tb_systray_clock,
1562                     DateFormat.getTimeFormat(context).format(new Date()),
1563                     DateFormat.getDateFormat(context).format(new Date())));
1564             time.setTextColor(U.getAccentColor(context));
1565         });
1566     }
1567
1568     @TargetApi(Build.VERSION_CODES.M)
1569     private Drawable getBatteryDrawable() {
1570         BatteryManager bm = (BatteryManager) context.getSystemService(Context.BATTERY_SERVICE);
1571         int batLevel = bm.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY);
1572
1573         if(batLevel == Integer.MIN_VALUE)
1574             return null;
1575
1576         IntentFilter ifilter = new IntentFilter(Intent.ACTION_BATTERY_CHANGED);
1577         Intent batteryStatus = context.registerReceiver(null, ifilter);
1578
1579         int status = batteryStatus.getIntExtra(BatteryManager.EXTRA_STATUS, -1);
1580         boolean isCharging = status == BatteryManager.BATTERY_STATUS_CHARGING ||
1581                 status == BatteryManager.BATTERY_STATUS_FULL;
1582
1583         String batDrawable;
1584         if(batLevel < 10 && !isCharging)
1585             batDrawable = "alert";
1586         else if(batLevel < 25)
1587             batDrawable = "20";
1588         else if(batLevel < 40)
1589             batDrawable = "30";
1590         else if(batLevel < 55)
1591             batDrawable = "50";
1592         else if(batLevel < 70)
1593             batDrawable = "60";
1594         else if(batLevel < 85)
1595             batDrawable = "80";
1596         else if(batLevel < 95)
1597             batDrawable = "90";
1598         else
1599             batDrawable = "full";
1600
1601         String charging;
1602         if(isCharging)
1603             charging = "charging_";
1604         else
1605             charging = "";
1606
1607         String batRes = "tb_battery_" + charging + batDrawable;
1608         int id = getResourceIdFor(batRes);
1609
1610         return getDrawableForSysTray(id);
1611     }
1612
1613     @TargetApi(Build.VERSION_CODES.M)
1614     private Drawable getWifiDrawable() {
1615         ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
1616
1617         NetworkInfo ethernet = manager.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
1618         if(ethernet != null && ethernet.isConnected())
1619             return getDrawableForSysTray(R.drawable.tb_settings_ethernet);
1620
1621         NetworkInfo wifi = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
1622         if(wifi == null || !wifi.isConnected())
1623             return null;
1624
1625         WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService(Context.WIFI_SERVICE);
1626         int numberOfLevels = 5;
1627
1628         WifiInfo wifiInfo = wifiManager.getConnectionInfo();
1629         int level = WifiManager.calculateSignalLevel(wifiInfo.getRssi(), numberOfLevels);
1630
1631         String wifiRes = "tb_signal_wifi_" + level + "_bar";
1632         int id = getResourceIdFor(wifiRes);
1633
1634         return getDrawableForSysTray(id);
1635     }
1636
1637     private Drawable getBluetoothDrawable() {
1638         BluetoothAdapter adapter = BluetoothAdapter.getDefaultAdapter();
1639         if(adapter != null && adapter.isEnabled())
1640             return getDrawableForSysTray(R.drawable.tb_bluetooth);
1641
1642         return null;
1643     }
1644
1645     @TargetApi(Build.VERSION_CODES.M)
1646     private Drawable getCellularDrawable() {
1647         if(Settings.Global.getInt(context.getContentResolver(), Settings.Global.AIRPLANE_MODE_ON, 0) != 0)
1648             return getDrawableForSysTray(R.drawable.tb_airplanemode_active);
1649
1650         if(cellStrength == -1)
1651             return null;
1652
1653         String cellRes = "tb_signal_cellular_" + cellStrength + "_bar";
1654         int id = getResourceIdFor(cellRes);
1655
1656         return getDrawableForSysTray(id);
1657     }
1658
1659     private Drawable getDrawableForSysTray(int id) {
1660         Drawable drawable = null;
1661         try {
1662             drawable = ContextCompat.getDrawable(context, id);
1663         } catch (Resources.NotFoundException e) { /* Gracefully fail */ }
1664
1665         if(drawable == null) return null;
1666
1667         drawable.setTint(U.getAccentColor(context));
1668         return drawable;
1669     }
1670
1671     private int getResourceIdFor(String name) {
1672         String packageName = context.getResources().getResourcePackageName(R.drawable.tb_dummy);
1673         return context.getResources().getIdentifier(name, "drawable", packageName);
1674     }
1675 }