API tools faq
paste
Guest User

Untitled

a guest
Oct 18th, 2017
65
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 20.42 KB | None | 0 0
raw download clone embed print report
  1. private String getTopPackageName() {
  2.  
  3.  
  4. if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
  5. UsageStatsManager usm = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
  6. long time = System.currentTimeMillis();
  7. List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time-1000*1000, time);
  8. if (appList != null && appList.size() > 0) {
  9. SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
  10. for (UsageStats usageStats : appList) {
  11. mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
  12. }
  13. if (mySortedMap != null && !mySortedMap.isEmpty()) {
  14. currentApp = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
  15. }
  16. }
  17. } else {
  18. mActivityManager = (ActivityManager)this.getSystemService(Context.ACTIVITY_SERVICE);
  19. List<ActivityManager.RunningAppProcessInfo> tasks = mActivityManager.getRunningAppProcesses();
  20. currentApp = tasks.get(0).processName;
  21. }
  22.  
  23. return currentApp;
  24. }
  25.  
  26. public class AppLockService extends Service {
  27.  
  28. public static final String BROADCAST_SERVICE_STARTED = "com.appslocker.locker.intent.action.service_started";
  29. /**
  30. * Sent to {@link MainActivity} when the service has been stopped
  31. */
  32. public static final String BROADCAST_SERVICE_STOPPED = "com.appslocker.locker.intent.action.service_stopped";
  33. /**
  34. * This category allows the receiver to receive actions relating to the
  35. * state of the service, such as when it is started or stopped
  36. */
  37. public static final String CATEGORY_STATE_EVENTS = "com.appslocker.locker.intent.category.service_start_stop_event";
  38.  
  39. private static final int REQUEST_CODE = 0x1234AF;
  40. public static final int NOTIFICATION_ID = 0xABCD32;
  41. private static final String TAG = "AppLockService";
  42.  
  43. /**
  44. * Use this action to stop the intent
  45. */
  46. private static final String ACTION_STOP = "com.apsscloker.locker.intent.action.stop_lock_service";
  47. /**
  48. * Starts the alarm
  49. */
  50. private static final String ACTION_START = "com.appslocker.locker.intent.action.start_lock_service";
  51. /**
  52. * When specifying this action, the service will initialize everything
  53. * again.<br>
  54. * This has only effect if the service was explicitly started using
  55. * {@link #getRunIntent(Context)}
  56. */
  57. private static final String ACTION_RESTART = "com.appslocker.locker.intent.action.restart_lock_service";
  58.  
  59. private static final String EXTRA_FORCE_RESTART = "com.appslocker.locker.intent.extra.force_restart";
  60. private ActivityManager mActivityManager;
  61.  
  62. /**
  63. * 0 for disabled
  64. */
  65. private long mShortExitMillis;
  66.  
  67. private boolean mRelockScreenOff;
  68. private boolean mShowNotification;
  69.  
  70. private boolean mExplicitStarted;
  71. private boolean mAllowDestroy;
  72. private boolean mAllowRestart;
  73. private Handler mHandler;
  74. private BroadcastReceiver mScreenReceiver;
  75. private String currentApp;
  76. /**
  77. * This map contains locked apps in the form<br>
  78. * <PackageName, ShortExitEndTime>
  79. */
  80. private Map<String, Boolean> mLockedPackages;
  81. private Map<String, Runnable> mUnlockMap;
  82.  
  83. @Override
  84. public IBinder onBind(Intent i) {
  85. return new LocalBinder();
  86. }
  87.  
  88. public class LocalBinder extends Binder {
  89. public AppLockService getInstance() {
  90. return AppLockService.this;
  91. }
  92. }
  93.  
  94. private final class ScreenReceiver extends BroadcastReceiver {
  95.  
  96. @Override
  97. public void onReceive(Context context, Intent intent) {
  98. if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
  99. Log.i(TAG, "Screen ON");
  100. // Trigger package again
  101. mLastPackageName = "";
  102. startAlarm(AppLockService.this);
  103. }
  104. if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
  105. Log.i(TAG, "Screen OFF");
  106. stopAlarm(AppLockService.this);
  107. if (mRelockScreenOff) {
  108. lockAll();
  109. }
  110. }
  111. }
  112. }
  113.  
  114. ;
  115.  
  116. @Override
  117. public void onCreate() {
  118. super.onCreate();
  119. Log.d(TAG, "onCreate");
  120.  
  121. }
  122.  
  123. /**
  124. * Starts everything, including notification and repeating alarm
  125. *
  126. * @return True if all OK, false if the service is not allowed to start (the
  127. * caller should stop the service)
  128. */
  129. private boolean init() {
  130. Log.d(TAG, "init");
  131. if (new PrefUtils(this).isCurrentPasswordEmpty()) {
  132. Log.w(TAG, "Not starting service, current password empty");
  133. return false;
  134. }
  135.  
  136.  
  137. mHandler = new Handler();
  138. mActivityManager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
  139.  
  140. mUnlockMap = new HashMap<>();
  141. mLockedPackages = new HashMap<>();
  142. mScreenReceiver = new ScreenReceiver();
  143. IntentFilter filter = new IntentFilter();
  144. filter.addAction(Intent.ACTION_SCREEN_ON);
  145. filter.addAction(Intent.ACTION_SCREEN_OFF);
  146. registerReceiver(mScreenReceiver, filter);
  147.  
  148. final Set<String> apps = PrefUtils.getLockedApps(this);
  149. for (String s : apps) {
  150. mLockedPackages.put(s, true);
  151. }
  152. PrefUtils prefs = new PrefUtils(this);
  153. boolean delay = prefs.getBoolean(R.string.pref_key_delay_status,
  154. R.bool.pref_def_delay_status);
  155.  
  156. if (delay) {
  157. int secs = prefs.parseInt(R.string.pref_key_delay_time,
  158. R.string.pref_def_delay_time);
  159. mShortExitMillis = secs * 1000;
  160. }
  161.  
  162. mRelockScreenOff = prefs.getBoolean(
  163. R.string.pref_key_relock_after_screenoff,
  164. R.bool.pref_def_relock_after_screenoff);
  165.  
  166. startNotification();
  167. startAlarm(this);
  168.  
  169. // Tell MainActivity we're done
  170. Intent i = new Intent(BROADCAST_SERVICE_STARTED);
  171. i.addCategory(CATEGORY_STATE_EVENTS);
  172. sendBroadcast(i);
  173. return true;
  174. }
  175.  
  176. @Override
  177. public int onStartCommand(Intent intent, int flags, int startId) {
  178. // Log.d(TAG, "test");
  179. if (intent == null || ACTION_START.equals(intent.getAction())) {
  180. if (!mExplicitStarted) {
  181. Log.d(TAG, "explicitStarted = false");
  182. if (init() == false) {
  183. doStopSelf();
  184. return START_NOT_STICKY;
  185. }
  186. mExplicitStarted = true;
  187. }
  188. checkPackageChanged();
  189. } else if (ACTION_RESTART.equals(intent.getAction())) {
  190. if (mExplicitStarted
  191. || intent.getBooleanExtra(EXTRA_FORCE_RESTART, false)) {
  192. Log.d(TAG,
  193. "ACTION_RESTART (force="
  194. + intent.getBooleanExtra(EXTRA_FORCE_RESTART,
  195. false));
  196. // init();
  197. doRestartSelf(); // not allowed, so service will restart
  198. } else {
  199. doStopSelf();
  200. }
  201. } else if (ACTION_STOP.equals(intent.getAction())) {
  202. Log.d(TAG, "ACTION_STOP");
  203. doStopSelf();
  204. }
  205.  
  206. return START_STICKY;
  207. }
  208.  
  209. private String mLastPackageName;
  210.  
  211.  
  212. private void checkPackageChanged() {
  213. final String packageName = getTopPackageName();
  214. // final String completeName = packageName + "/"
  215. // + top.topActivity.getShortClassName();
  216.  
  217. if (!packageName.equals(mLastPackageName)) {
  218. Log.d(TAG, "appchanged " + " (" + mLastPackageName + ">"
  219. + packageName + ")");
  220.  
  221. onAppClose(mLastPackageName, packageName);
  222. onAppOpen(packageName, mLastPackageName);
  223. }
  224.  
  225. // prepare for next call
  226. mLastPackageName = packageName;
  227. // mLastCompleteName = completeName;
  228. }
  229.  
  230. private void onAppOpen(final String open, final String close) {
  231. if (mLockedPackages.containsKey(open)) {
  232. onLockedAppOpen(open);
  233. }
  234. }
  235.  
  236. private void onLockedAppOpen(final String open) {
  237. final boolean locked = mLockedPackages.get(open);
  238. // Log.d(TAG, "onLockedAppOpen (locked=" + locked + ")");
  239. if (locked) {
  240. showLocker(open);
  241. }
  242. removeRelockTimer(open);
  243. }
  244.  
  245. private void showLocker(String packageName) {
  246. Intent intent = LockService.getLockIntent(getApplicationContext(), packageName);
  247. intent.setAction(LockService.ACTION_COMPARE);
  248. intent.putExtra(LockService.EXTRA_PACKAGENAME, packageName);
  249. startService(intent);
  250.  
  251. }
  252.  
  253. private void showLockerForCategory(String category) {
  254. Intent intent = LockService.getLockIntentForCategory(this, category);
  255. intent.setAction(LockService.ACTION_COMPARE);
  256. intent.putExtra(LockService.EXTRA_CATEGORY, category);
  257. startService(intent);
  258.  
  259. }
  260.  
  261. private void onAppClose(String close, String open) {
  262. if (mLockedPackages.containsKey(close)) {
  263. onLockedAppClose(close, open);
  264. }
  265. }
  266.  
  267. private void onLockedAppClose(String close, String open) {
  268. //showInterstitial();
  269.  
  270. setRelockTimer(close);
  271.  
  272. if (getPackageName().equals(close) || getPackageName().equals(open)) {
  273. // Don't interact with own app
  274. return;
  275. }
  276.  
  277. if (mLockedPackages.containsKey(open)) {
  278. // The newly opened app needs a lock screen, so don't hide previous
  279. return;
  280. }
  281. LockService.hide(this);
  282. }
  283.  
  284. private void setRelockTimer(String packageName) {
  285. boolean locked = mLockedPackages.get(packageName);
  286. if (!locked) {
  287. if (mShortExitMillis != 0) {
  288. Runnable r = new RelockRunnable(packageName);
  289. mHandler.postDelayed(r, mShortExitMillis);
  290. mUnlockMap.put(packageName, r);
  291. } else {
  292. lockApp(packageName);
  293. }
  294. }
  295. }
  296.  
  297. private void removeRelockTimer(String packageName) {
  298. // boolean locked = mLockedPackages.get(packageName);
  299. // if (!locked) {
  300. if (mUnlockMap.containsKey(packageName)) {
  301. mHandler.removeCallbacks(mUnlockMap.get(packageName));
  302. mUnlockMap.remove(packageName);
  303. }
  304. }
  305.  
  306. /**
  307. * This class will re-lock an app
  308. */
  309. private class RelockRunnable implements Runnable {
  310. private final String mPackageName;
  311.  
  312. public RelockRunnable(String packageName) {
  313. mPackageName = packageName;
  314. }
  315.  
  316. @Override
  317. public void run() {
  318. lockApp(mPackageName);
  319. }
  320. }
  321.  
  322. List<RunningTaskInfo> mTestList = new ArrayList<>();
  323.  
  324.  
  325. private String getTopPackageName() {
  326.  
  327.  
  328. if(android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.LOLLIPOP) {
  329. UsageStatsManager usm = (UsageStatsManager) this.getSystemService(Context.USAGE_STATS_SERVICE);
  330. long time = System.currentTimeMillis();
  331. List<UsageStats> appList = usm.queryUsageStats(UsageStatsManager.INTERVAL_DAILY, time-1000*1000, time);
  332. if (appList != null && appList.size() > 0) {
  333. SortedMap<Long, UsageStats> mySortedMap = new TreeMap<Long, UsageStats>();
  334. for (UsageStats usageStats : appList) {
  335. mySortedMap.put(usageStats.getLastTimeUsed(), usageStats);
  336. }
  337. if (mySortedMap != null && !mySortedMap.isEmpty()) {
  338. currentApp = mySortedMap.get(mySortedMap.lastKey()).getPackageName();
  339. }
  340. }
  341. } else {
  342. mActivityManager = (ActivityManager)this.getSystemService(Context.ACTIVITY_SERVICE);
  343. List<ActivityManager.RunningAppProcessInfo> tasks = mActivityManager.getRunningAppProcesses();
  344. currentApp = tasks.get(0).processName;
  345. }
  346.  
  347. return currentApp;
  348.  
  349. /* if (Build.VERSION.SDK_INT > 20) {
  350. return mActivityManager.getRunningAppProcesses().get(0).processName;
  351. // mClassName = activityManager.getRunningAppProcesses().get(0).getClass().getName();
  352. } else {
  353. return mActivityManager.getRunningTasks(1).get(0).topActivity.getPackageName();
  354. // mClassName = activityManager.getRunningTasks(1).get(0).topActivity.getClassName();
  355. }*/
  356.  
  357. }
  358.  
  359. public void unlockApp(String packageName) {
  360. Log.d(TAG, "unlocking app (packageName=" + packageName + ")");
  361. if (mLockedPackages.containsKey(packageName)) {
  362. mLockedPackages.put(packageName, false);
  363. }
  364. }
  365.  
  366. private void lockAll() {
  367. for (Map.Entry<String, Boolean> entry : mLockedPackages.entrySet()) {
  368. entry.setValue(true);
  369. }
  370. }
  371.  
  372. void lockApp(String packageName) {
  373. if (mLockedPackages.containsKey(packageName)) {
  374. mLockedPackages.put(packageName, true);
  375. }
  376. }
  377.  
  378. private void startNotification() {
  379.  
  380. // Start foreground anyway
  381. startForegroundWithNotification();
  382.  
  383. mShowNotification = new PrefUtils(this).getBoolean(
  384. R.string.pref_key_show_notification,
  385. R.bool.pref_def_show_notification);
  386.  
  387. }
  388.  
  389. @SuppressLint("InlinedApi")
  390. private void startForegroundWithNotification() {
  391. Log.d(TAG, "showNotification");
  392.  
  393. boolean hide = new PrefUtils(this).getBoolean(
  394. R.string.pref_key_hide_notification_icon,
  395. R.bool.pref_def_hide_notification_icon);
  396. int priority = hide ? Notification.PRIORITY_MIN
  397. : Notification.PRIORITY_DEFAULT;
  398. Intent i = new Intent(this, MainActivity.class);
  399. PendingIntent pi = PendingIntent.getActivity(this, 0, i, 0);
  400. String title = getString(R.string.notification_title);
  401. String content = getString(R.string.notification_state_locked);
  402. NotificationCompat.Builder nb = new NotificationCompat.Builder(this);
  403. nb.setSmallIcon(R.drawable.ic_launcher);
  404. nb.setContentTitle(title);
  405. nb.setContentText(content);
  406. nb.setWhen(System.currentTimeMillis());
  407. nb.setContentIntent(pi);
  408. nb.setOngoing(true);
  409. nb.setPriority(priority);
  410.  
  411. startForeground(NOTIFICATION_ID, nb.build());
  412. }
  413.  
  414. public static void start(Context c) {
  415. startAlarm(c);
  416. }
  417.  
  418. /**
  419. * @param c
  420. * @return The new state for the service, true for running, false for not
  421. * running
  422. */
  423. public static boolean toggle(Context c) {
  424. if (isRunning(c)) {
  425. stop(c);
  426. return false;
  427. } else {
  428. start(c);
  429. return true;
  430. }
  431.  
  432. }
  433.  
  434. public static boolean isRunning(Context c) {
  435. ActivityManager manager = (ActivityManager) c
  436. .getSystemService(Context.ACTIVITY_SERVICE);
  437. for (RunningServiceInfo service : manager
  438. .getRunningServices(Integer.MAX_VALUE)) {
  439. if (AppLockService.class.getName().equals(
  440. service.service.getClassName())) {
  441. return true;
  442. }
  443. }
  444. return false;
  445. }
  446.  
  447. /**
  448. * Starts the service
  449. */
  450. private static void startAlarm(Context c) {
  451. AlarmManager am = (AlarmManager) c.getSystemService(ALARM_SERVICE);
  452. PendingIntent pi = getRunIntent(c);
  453. SharedPreferences sp = PrefUtils.prefs(c);
  454. String defaultPerformance = c.getString(R.string.pref_val_perf_normal);
  455. String s = sp.getString(c.getString(R.string.pref_key_performance),
  456. defaultPerformance);
  457. if (s.length() == 0)
  458. s = "0";
  459. long interval = Long.parseLong(s);
  460. Log.d(TAG, "Scheduling alarm (interval=" + interval + ")");
  461. long startTime = SystemClock.elapsedRealtime();
  462. am.setRepeating(AlarmManager.ELAPSED_REALTIME, startTime, interval, pi);
  463. }
  464.  
  465. private static PendingIntent running_intent;
  466.  
  467. private static PendingIntent getRunIntent(Context c) {
  468. if (running_intent == null) {
  469. Intent i = new Intent(c, AppLockService.class);
  470. i.setAction(ACTION_START);
  471. running_intent = PendingIntent.getService(c, REQUEST_CODE, i, 0);
  472. }
  473. return running_intent;
  474. }
  475.  
  476. private static void stopAlarm(Context c) {
  477. AlarmManager am = (AlarmManager) c.getSystemService(ALARM_SERVICE);
  478. am.cancel(getRunIntent(c));
  479. }
  480.  
  481. /**
  482. * Stop this service, also stopping the alarm
  483. */
  484. public static void stop(Context c) {
  485. stopAlarm(c);
  486. Intent i = new Intent(c, AppLockService.class);
  487. i.setAction(ACTION_STOP);
  488. c.startService(i);
  489. }
  490.  
  491. /**
  492. * Re-initialize everything.<br>
  493. * This has only effect if the service was explicitly started using
  494. * {@link #start(Context)}
  495. */
  496. public static void restart(Context c) {
  497. Intent i = new Intent(c, AppLockService.class);
  498. i.setAction(ACTION_RESTART);
  499. c.startService(i);
  500. }
  501.  
  502. /**
  503. * Forces the service to stop and then start again. This means that if the
  504. * service was already stopped, it will just start
  505. */
  506. public static void forceRestart(Context c) {
  507. Intent i = new Intent(c, AppLockService.class);
  508. i.setAction(ACTION_RESTART);
  509. i.putExtra(EXTRA_FORCE_RESTART, true);
  510. c.startService(i);
  511. }
  512.  
  513. @Override
  514. public void onDestroy() {
  515. super.onDestroy();
  516. Log.d(TAG, "onDestroy: (mAllowRestart=" + mAllowRestart + ")");
  517. if (mScreenReceiver != null)
  518. unregisterReceiver(mScreenReceiver);
  519. if (mShowNotification)
  520. stopForeground(true);
  521.  
  522. if (mAllowRestart) {
  523. start(this);
  524. mAllowRestart = false;
  525. return;
  526. }
  527.  
  528. Log.i(TAG, "onDestroy (mAllowDestroy=" + mAllowDestroy + ")");
  529. if (!mAllowDestroy) {
  530. Log.d(TAG, "Destroy not allowed, restarting service");
  531. start(this);
  532. } else {
  533. // Tell MainActivity we're stopping
  534. Intent i = new Intent(BROADCAST_SERVICE_STOPPED);
  535. i.addCategory(CATEGORY_STATE_EVENTS);
  536. sendBroadcast(i);
  537. }
  538. mAllowDestroy = false;
  539. }
  540.  
  541. private void doStopSelf() {
  542. stopAlarm(this);
  543. mAllowDestroy = true;
  544. stopForeground(true);
  545. stopSelf();
  546. }
  547.  
  548. private void doRestartSelf() {
  549. Log.d(TAG, "Setting allowrestart to true");
  550. mAllowRestart = true;
  551. stopSelf();
  552. }
  553. }
  554.  
  555. <uses-sdk
  556. android:minSdkVersion="15"
  557. android:targetSdkVersion="23" />
  558.  
  559. <supports-screens
  560. android:anyDensity="true"
  561. android:largeScreens="true"
  562. android:normalScreens="true"
  563. android:smallScreens="true" />
  564.  
  565. <uses-feature
  566. android:name="android.hardware.telephony"
  567. android:required="false" />
  568. <uses-feature
  569. android:name="android.hardware.usb.accessory"
  570. android:required="false" />
  571. <uses-feature
  572. android:name="android.hardware.usb.host"
  573. android:required="false" />
  574. <uses-feature
  575. android:name="android.hardware.location"
  576. android:required="false" />
  577. <uses-feature
  578. android:name="android.hardware.wifi"
  579. android:required="false" />
  580.  
  581. <!-- permissions -->
  582. <uses-permission android:name="android.permission.GET_TASKS" />
  583. <uses-permission android:name="android.permission.PACKAGE_USAGE_STATS" tools:ignore="ProtectedPermissions" />
  584. <uses-permission android:name="android.permission.VIBRATE" />
  585. <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
  586. <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
  587. <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  588. <uses-permission android:name="android.permission.MANAGE_DOCUMENTS" />
  589. <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW" />
  590. <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  591. <uses-permission android:name="android.permission.READ_PHONE_STATE" />
  592.  
  593. <application
  594. android:allowBackup="false"
  595. android:icon="@drawable/ic_launcher"
  596. android:label="@string/application_name"
  597. android:theme="@style/Theme.AppCompat"
  598. android:largeHeap="true"
  599. tools:node="replace">
  600. <activity
  601. android:name="com.appslocker.locker.ui.MainActivity"
  602. android:label="@string/application_name">
  603. <intent-filter>
  604. <action android:name="android.intent.action.MAIN" />
  605. <action android:name="android.intent.action.SEARCH" />
  606.  
  607. <category android:name="android.intent.category.LAUNCHER" />
  608. </intent-filter>
  609. </activity>
  610.  
  611. <service android:name="com.appslocker.locker.lock.AppLockService" />
  612. <service android:name="com.appslocker.locker.lock.LockService" />
  613.  
  614. <receiver android:name="com.appslocker.locker.receivers.BootCompleteReceiver">
  615. <intent-filter>
  616. <action android:name="android.intent.action.BOOT_COMPLETED" />
  617. <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
  618. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLE_REQUESTED" />
  619. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLED" />
  620. </intent-filter>
  621. </receiver>
  622. <receiver
  623. android:name=".DeviceAdmenReciever"
  624. android:permission="android.permission.BIND_DEVICE_ADMIN">
  625. <meta-data
  626. android:name="android.app.device_admin"
  627. android:resource="@xml/device_admin" />
  628.  
  629. <intent-filter>
  630. <action android:name="android.app.action.DEVICE_ADMIN_ENABLED" />
  631. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLE_REQUESTED" />
  632. <action android:name="android.app.action.ACTION_DEVICE_ADMIN_DISABLED" />
  633. </intent-filter>
  634. </receiver>
  635.  
  636. <meta-data
  637. android:name="com.google.android.gms.version"
  638. android:value="@integer/google_play_services_version" />
  639.  
  640. <service
  641. android:name=".MyAccessibilityService"
  642. android:label="@string/accessibility_service_label"
  643. android:permission="android.permission.BIND_ACCESSIBILITY_SERVICE" >
  644. <intent-filter>
  645. <action android:name="android.accessibilityservice.AccessibilityService" />
  646. </intent-filter>
  647.  
  648. <meta-data
  649. android:name="android.accessibilityservice"
  650. android:resource="@xml/accessibility_service_config" />
  651. </service>
  652.  
  653.  
  654. </application>
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!