import android.annotation.SuppressLint;
import android.app.Dialog;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.graphics.Paint.Style;
import android.graphics.RectF;
import android.graphics.SweepGradient;
import android.os.Bundle;
import android.view.MotionEvent;
import android.view.View;

@SuppressLint({ “DrawAllocation” })
public class ColorPickerDialog extends Dialog {
private int mInitialColor;
private OnColorChangedListener mListener;

public ColorPickerDialog(Context paramContext,
        OnColorChangedListener paramOnColorChangedListener, int paramInt) {
    super(paramContext);
    this.mListener = paramOnColorChangedListener;
    this.mInitialColor = paramInt;
}

protected void onCreate(Bundle paramBundle) {
    super.onCreate(paramBundle);
    mListener = new OnColorChangedListener() {
        public void colorChanged(int paramAnonymousInt) {
            ColorPickerDialog.this.mListener
                    .colorChanged(paramAnonymousInt);
            ColorPickerDialog.this.dismiss();
        }
    };
    setContentView(new ColorPickerView(getContext(), mListener,
            this.mInitialColor));
    setTitle("Pick a Color");
}

private static class ColorPickerView extends View {
    private static final int CENTER_RADIUS = 32;
    private static int CENTER_X = 120;
    private static int CENTER_Y = 120;
    private static final float PI = 3.1415925F;
    private Paint mCenterPaint;
    private final int[] mColors;
    private boolean mHighlightCenter;
    private ColorPickerDialog.OnColorChangedListener mListener;
    private Paint mPaint;
    private boolean mTrackingCenter;

    ColorPickerView(
            Context paramContext,
            ColorPickerDialog.OnColorChangedListener paramOnColorChangedListener,
            int paramInt) {
        super(paramContext);
        this.mListener = paramOnColorChangedListener;
        this.mColors = new int[] { -65536, -65281, -16776961, -16711681,
                -16711936, 65280, -65536 };
        SweepGradient gradient = new SweepGradient(0.0F, 0.0F,
                this.mColors, null);
        this.mPaint = new Paint(1);
        this.mPaint.setShader(gradient);
        this.mPaint.setStyle(Paint.Style.STROKE);
        this.mPaint.setStrokeWidth(32.0F);
        this.mCenterPaint = new Paint(1);
        this.mCenterPaint.setColor(paramInt);
        this.mCenterPaint.setStrokeWidth(5.0F);
    }

    private int ave(int paramInt1, int paramInt2, float paramFloat) {
        return Math.round((paramInt2 - paramInt1) * paramFloat) + paramInt1;
    }

    private int interpColor(int[] paramArrayOfInt, float paramFloat) {
        if (paramFloat <= 0.0F) {
            return paramArrayOfInt[0];
        }
        if (paramFloat >= 1.0F) {
            return paramArrayOfInt[(paramArrayOfInt.length - 1)];
        }
        paramFloat *= (paramArrayOfInt.length - 1);
        int j = (int) paramFloat;
        paramFloat -= j;
        int i = paramArrayOfInt[j];
        j = paramArrayOfInt[(j + 1)];
        return Color.argb(ave(Color.alpha(i), Color.alpha(j), paramFloat),
                ave(Color.red(i), Color.red(j), paramFloat),
                ave(Color.green(i), Color.green(j), paramFloat),
                ave(Color.blue(i), Color.blue(j), paramFloat));
    }

    protected void onDraw(Canvas paramCanvas) {
        float f = CENTER_X - this.mPaint.getStrokeWidth() * 0.5F;
        paramCanvas.translate(CENTER_X, CENTER_X);
        paramCanvas.drawOval(new RectF(-f, -f, f, f), this.mPaint);
        paramCanvas.drawCircle(0.0F, 0.0F, 32.0F, this.mCenterPaint);
        int i;
        if (this.mTrackingCenter) {
            i = this.mCenterPaint.getColor();
            this.mCenterPaint.setStyle(Paint.Style.STROKE);
            if (this.mHighlightCenter) {
                this.mCenterPaint.setAlpha(255);
            } else {
                this.mCenterPaint.setAlpha(128);
            }
            paramCanvas.drawCircle(0.0F, 0.0F,
                    this.mCenterPaint.getStrokeWidth() + 32.0F,
                    this.mCenterPaint);
            this.mCenterPaint.setStyle(Paint.Style.FILL);
            this.mCenterPaint.setColor(i);

        }
    }

    protected void onMeasure(int paramInt1, int paramInt2) {
        setMeasuredDimension(CENTER_X * 2, CENTER_X * 2);
    }

    public boolean onTouchEvent(MotionEvent paramMotionEvent) {
        float f1 = paramMotionEvent.getX() - CENTER_X;
        float f2 = paramMotionEvent.getY() - CENTER_Y;
        boolean bool;
        if (Math.sqrt(f1 * f1 + f2 * f2) <= 32.0D) {
            bool = true;
        } else {
            bool = false;
        }
        switch (paramMotionEvent.getAction()) {
        case 0:
            return true;

        case 1:

            if (mTrackingCenter) {
                if (mTrackingCenter != bool) {
                    this.mHighlightCenter = bool;
                    invalidate();
                    return true;
                } else {
                    f2 = (float) Math.atan2(f2, f1) / 6.283185F;
                    f1 = f2;
                    if (f2 < 0.0F) {
                        f1 = f2 + 1.0F;
                    }
                    this.mCenterPaint
                            .setColor(interpColor(this.mColors, f1));
                    invalidate();
                    return true;
                }
            }
            break;

        case 2:

            if (mTrackingCenter) {
                if (bool) {
                    this.mListener.colorChanged(this.mCenterPaint
                            .getColor());
                }
                this.mTrackingCenter = false;
                invalidate();
                return true;
            }
        }

        return false;
    }
}

public static abstract interface OnColorChangedListener {
    public abstract void colorChanged(int paramInt);
}

}

作者 east

Android 2月 11,2021

Android手电筒后台Service

功能是后台service控制手电的打开和关闭。

public class ToggleFlashService extends Service {
	final String SMS_RECEIVED_STRING = "android.provider.Telephony.SMS_RECEIVED";
	AudioManager audioManager;
	int callState;
	int flashDuration;
	int flashInterval;
	boolean isCameraInUse = false;
	boolean isCameraOpen = false;
	boolean isFlashOn = false;
	Camera.Parameters params;
	Intent serviceIntent;
	TelephonyManager telephonyManager;
	Timer timer;
	TimerTask timerTask;

	public boolean isCameraInUse() {
		try {
			if ((ToggleFlashSettings.camera == null) && (!this.isCameraOpen)) {
				ToggleFlashSettings.camera = Camera.open();
				this.params = ToggleFlashSettings.camera.getParameters();
				this.isCameraOpen = true;
				return false;
			}			
		} catch (Exception localException) {
		}
		return true;
	}

	public void messageReceived() {
	}

	public IBinder onBind(Intent paramIntent) {
		return null;
	}

	public void onCreate() {
		this.telephonyManager = ((TelephonyManager) getSystemService("phone"));
		this.audioManager = ((AudioManager) getSystemService("audio"));
		this.callState = this.telephonyManager.getCallState();
		this.flashDuration = ToggleFlashPrefs
				.getCallFlashInterval(getApplicationContext());
		this.flashInterval = ToggleFlashPrefs
				.getCallFlashDuration(getApplicationContext());
		super.onCreate();
	}


	public void onDestroy() {
		Log.e("Toggle", "ToggleFlash Destroy");
		try {
			if (this.timer != null) {
				this.timer.cancel();
				this.timer = null;
			}
			if ((this.isFlashOn) && (ToggleFlashSettings.camera != null)) {
				this.isFlashOn = false;
				this.isCameraOpen = false;
				this.params = ToggleFlashSettings.camera.getParameters();
				List localList = this.params.getSupportedFlashModes();
				if ((localList.contains("torch"))
						|| (localList.contains("off"))
						|| (localList.contains("on"))) {
					this.params.setFlashMode("off");
					ToggleFlashSettings.camera.setParameters(this.params);
				}
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}			
		} catch (Exception localException) {
			if (ToggleFlashSettings.camera != null) {
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			localException.printStackTrace();
		}
	}


	public int onStartCommand(Intent paramIntent, int paramInt1, int paramInt2) {
		if (ToggleFlashSettings.camera != null) {
			ToggleFlashSettings.camera.release();
			ToggleFlashSettings.camera = null;
		}
		this.serviceIntent = paramIntent;
		this.telephonyManager.listen(new PhoneStateListener() {
			public void onCallStateChanged(int paramAnonymousInt,
					String paramAnonymousString) {
				switch (paramAnonymousInt) {
				default:
					ToggleFlashService.this.callState = 0;
					break;
				case 1:
					ToggleFlashService.this.callState = 1;
					break;
				case 2:
					ToggleFlashService.this.callState = 2;
					break;
				}

			}
		}, 32);
		this.timer = new Timer();
		this.timerTask = new TimerTask() {
			public void run() {
				ToggleFlashService.this.toggleFlash();
			}
		};
		if (this.flashDuration == 0) {
			this.timer.schedule(this.timerTask, this.flashInterval, 50L);
		} else {
			this.timer.schedule(this.timerTask, this.flashInterval,
					this.flashDuration);
		}
		return super.onStartCommand(paramIntent, paramInt1, paramInt2);
	}


	public boolean stopService(Intent paramIntent) {
		try {
			if (this.timer != null) {
				this.timer.cancel();
				this.timer = null;
			}
			if ((this.isFlashOn) && (ToggleFlashSettings.camera != null)) {
				this.isFlashOn = false;
				this.isCameraOpen = false;
				this.params = ToggleFlashSettings.camera.getParameters();
				List localList = this.params.getSupportedFlashModes();
				if ((localList.contains("torch"))
						|| (localList.contains("off"))
						|| (localList.contains("on"))) {
					this.params.setFlashMode("off");
					ToggleFlashSettings.camera.setParameters(this.params);
				}
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			this.isCameraOpen = false;
			this.isFlashOn = false;
			if (ToggleFlashSettings.camera != null) {
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			if (this.serviceIntent != null) {
				boolean bool = super.stopService(this.serviceIntent);
				return bool;
			}
		} catch (Exception localException) {
			localException.printStackTrace();
			if (ToggleFlashSettings.camera != null) {
				ToggleFlashSettings.camera.release();
				ToggleFlashSettings.camera = null;
			}
			ToggleFlashSettings.camera = null;
		}
		return super.stopService(paramIntent);
	}

	
	public void toggleFlash() {		
		try {
			this.isCameraInUse = isCameraInUse();
			if (this.isCameraInUse) {
				stopService(this.serviceIntent);
				Log.e("ToggleFlashServer", "is isCameraInUse ");     
				return;
			}
			if (this.callState != 1) {
				Log.e("ToggleFlashServer", "callState is 1 ");     
				return;
			}
			 List localList = this.params.getSupportedFlashModes();
			if (!this.isFlashOn) {
				if ((localList.contains("torch"))
						|| (localList.contains("off"))
						|| (localList.contains("on"))) {
					Log.e("ToggleFlashServer", "start torch.... ");    
					this.params.setFlashMode("torch");
					if (ToggleFlashSettings.camera != null) {
						ToggleFlashSettings.camera.setParameters(this.params);
						ToggleFlashSettings.camera.startPreview();
					}
				}
				this.isFlashOn = true;
				return;
			}
			
			if ((localList.contains("torch")) || (localList.contains("off"))
					|| (localList.contains("on"))) {
				this.params.setFlashMode("off");
				if (ToggleFlashSettings.camera != null) {
					ToggleFlashSettings.camera.setParameters(this.params);
					ToggleFlashSettings.camera.stopPreview();
				}
			}
			this.isFlashOn = false;
			stopService(this.serviceIntent);
			
		} catch (Exception localException) {
			localException.printStackTrace();

		}
		
	}
}


public class ToggleFlashPrefs {
	public static final String CALL_FLASH_DURATION = "call_flash_duration";
	public static final String CALL_FLASH_INTERVAL = "call_flash_interval";
	public static final String MSG_FLASH_DURATION = "msg_flash_duration";
	public static final String MSG_FLASH_INTERVAL = "msg_flash_interval";
	public static final String SERVICE_STARTED = "service_started";
	public static final String SET_ALARM_ENABLE = "set_alarm_enable";
	public static final String SET_CALL_ENABLE = "set_call_enable";
	public static final String SET_MESSAGE_ENABLE = "set_message_enable";
	public static final String SET_NOTIFICATION_ENABLE = "set_notification_enable";

	public static boolean getAlarmEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean(
				"set_alarm_enable", false);
	}

	public static boolean getCallEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean("set_call_enable",
				true);
	}

	public static int getCallFlashDuration(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("call_flash_duration",
				250);
	}

	public static int getCallFlashInterval(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("call_flash_interval",
				0);
	}

	public static int getMSGFlashDuration(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("msg_flash_duration",
				250);
	}

	public static int getMSGFlashInterval(Context paramContext) {
		return getSharedPreferences(paramContext).getInt("msg_flash_interval",
				0);
	}

	public static boolean getMessageEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean(
				"set_message_enable", true);
	}

	public static boolean getNotificationEnable(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean(
				"set_notification_enable", false);
	}

	public static boolean getServiceStarted(Context paramContext) {
		return getSharedPreferences(paramContext).getBoolean("service_started",
				false);
	}

	static SharedPreferences getSharedPreferences(Context paramContext) {
		return PreferenceManager.getDefaultSharedPreferences(paramContext);
	}

	public static void setAlarmEnable(Context paramContext, boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_alarm_enable", paramBoolean);
		editor.commit();
	}

	public static void setCallEnable(Context paramContext, boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_call_enable", paramBoolean);
		editor.commit();
	}

	public static void setCallFlashDuration(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("call_flash_duration", paramInt);
		editor.commit();
	}

	public static void setCallFlashInterval(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("call_flash_interval", paramInt);
		editor.commit();
	}

	public static void setMSGFlashDuration(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("msg_flash_duration", paramInt);
		editor.commit();
	}

	public static void setMSGFlashInterval(Context paramContext, int paramInt) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putInt("msg_flash_interval", paramInt);
		editor.commit();
	}

	public static void setMessageEnable(Context paramContext,
			boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_message_enable", paramBoolean);
		editor.commit();
	}

	public static void setNotificationEnable(Context paramContext,
			boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("set_notification_enable", paramBoolean);
		editor.commit();
	}

	public static void setServiceStarted(Context paramContext,
			boolean paramBoolean) {
		SharedPreferences.Editor editor = getSharedPreferences(paramContext)
				.edit();
		editor.putBoolean("service_started", paramBoolean);
		editor.commit();
	}
}

作者 east

Android 2月 11,2021

Android单行文本跑马灯控件

public class AutoScrollTextView extends TextView implements OnClickListener {
public final static String TAG = AutoScrollTextView.class.getSimpleName();
private int runNum = 1;// 滚动次数
private float textLength = 0f;// 文本长度
private float viewWidth = 0f;
private float step = 0f;// 文字的横坐标
private float y = 0f;// 文字的纵坐标
private float temp_view_plus_text_length = 0.0f;// 用于计算的临时变量
private float temp_view_plus_two_text_length = 0.0f;// 用于计算的临时变量
public boolean isStarting = false;// 是否开始滚动
private Paint paint = null;// 绘图样式
private Paint paint1 = null;// 绘图样式
private String text = “”;// 文本内容
private boolean isFade = true;// 是否加影子
private float layout_width = 168f;

public float getLayout_width() {
    return layout_width;
}

public void setLayout_width(float layoutWidth) {
    layout_width = layoutWidth;
}

public boolean isFade() {
    return isFade;
}

public void setFade(boolean isFade) {
    this.isFade = isFade;
}

public AutoScrollTextView(Context context) {
    super(context);
    initView();
}

public AutoScrollTextView(Context context, AttributeSet attrs) {
    super(context, attrs);
    initView();
}

public AutoScrollTextView(Context context, AttributeSet attrs, int defStyle) {
    super(context, attrs, defStyle);
    initView();
}

/** */
/**
 * 初始化控件
 */
private void initView() {
    setOnClickListener(this);
}

/** */
/**
 * 文本初始化，每次更改文本内容或者文本效果等之后都需要重新初始化一下
 */
public void init(WindowManager windowManager) {
    paint = getPaint();
    paint1 = new Paint();
    paint1.setColor(Color.WHITE);
    paint1.setTextSize(getTextSize());
    text = getText().toString();
    textLength = paint.measureText(text);
    viewWidth = layout_width * LogoActivity.screenHeight / 960;
    if (textLength > viewWidth * 2) {
        isStarting = true;
    }
    Log.e("    textLength      ", textLength + "         " + viewWidth);
    if (viewWidth == 0) {
        if (windowManager != null) {
            Display display = windowManager.getDefaultDisplay();
            viewWidth = display.getWidth();
        }
    }
    temp_view_plus_text_length = viewWidth + textLength;
    temp_view_plus_two_text_length = viewWidth + textLength * 2;
    step = temp_view_plus_text_length;
    y = getTextSize() + getPaddingTop();
}

@Override
public Parcelable onSaveInstanceState() {
    Parcelable superState = super.onSaveInstanceState();
    SavedState ss = new SavedState(superState);

    ss.step = step;
    ss.isStarting = isStarting;

    return ss;

}

@Override
public void onRestoreInstanceState(Parcelable state) {
    if (!(state instanceof SavedState)) {
        super.onRestoreInstanceState(state);
        return;
    }
    SavedState ss = (SavedState) state;
    super.onRestoreInstanceState(ss.getSuperState());

    step = ss.step;
    isStarting = ss.isStarting;

}

public static class SavedState extends BaseSavedState {
    public boolean isStarting = false;
    public float step = 0.0f;

    SavedState(Parcelable superState) {
        super(superState);
    }

    @Override
    public void writeToParcel(Parcel out, int flags) {
        super.writeToParcel(out, flags);
        out.writeBooleanArray(new boolean[] { isStarting });
        out.writeFloat(step);
    }

    public static final Parcelable.Creator<SavedState> CREATOR = new Parcelable.Creator<SavedState>() {

        public SavedState[] newArray(int size) {
            return new SavedState[size];
        }

        @Override
        public SavedState createFromParcel(Parcel in) {
            return new SavedState(in);
        }
    };

    private SavedState(Parcel in) {
        super(in);
        boolean[] b = null;
        in.readBooleanArray(b);
        if (b != null && b.length > 0)
            isStarting = b[0];
        step = in.readFloat();
    }
}

/** */
/**
 * 开始滚动
 */
public void startScroll() {
    isStarting = true;
    invalidate();
}

/** */
/**
 * 停止滚动
 */
public void stopScroll() {
    isStarting = false;
    runNum = 1;
    invalidate();

}

@Override
public void onDraw(Canvas canvas) {
    if (isFade)canvas.drawText(text, temp_view_plus_text_length - step, y, paint1);
    canvas.drawText(text, temp_view_plus_text_length - step, y - 1, paint);
    if (!isStarting) {
        return;
    }
    step += 1;
    if (step > temp_view_plus_two_text_length) {
        step = textLength - viewWidth;
        runNum--;

    }
    if (runNum == 0 && step == temp_view_plus_text_length) {
        isStarting = false;
    }
    invalidate();

}

@Override
public void onClick(View v) {

// if (isStarting)
// stopScroll();
// else
// startScroll();

}

作者 east

Android 2月 11,2021

Android游戏加载资源通用类

开发游戏，通常需要在Assets中加载图片和多语言包，下面有个封装类。

/**
 * 图片加载类.
 * 
 * @author 凉
 * 
 */
public class Assets {
	private static Map<String, Map<String, String>> drawables = new HashMap<String, Map<String, String>>();

	private static Map<String, String> raws = new HashMap<String, String>();

	/**
	 * 如果是中文,则从drawable-zh目录加载图片.如果没有,在从drawable里面加载.
	 * 
	 * @param name
	 * @return
	 */
	public static String get(String name) {
		String result = null;
		if (isLunarSetting()) {
			Map map = (Map) drawables.get("drawable-zh");
			if (map != null) {
				String str3 = get(map, name);
				MyLog.d("", ">>>>>>>>>>>path>>>cn>>drawables:" + str3
						+ "   name:" + name);
				if (str3 != null) {
					result = str3;
				} else {
					String str4 = get((Map) drawables.get("drawable"), name);
					MyLog.d("", ">>>>>>>>>>>path>>>en>1>drawables:" + str4
							+ "   name:" + name);
					if (str4 != null) {
						result = str4;
					}
				}
			} else {
				String str2 = get((Map) drawables.get("drawable"), name);
				MyLog.d("", ">>>>>>>>>>>path>>>en>2>drawables:" + str2
						+ "   name:" + name);
				if (str2 != null) {
					result = str2;
				}
			}
		} else {
			String str1 = get((Map) drawables.get("drawable"), name);
			MyLog.d("", ">>>>>>>>>>>path>>>en>3>drawables:" + str1 + "   name:"
					+ name);
			if (str1 != null) {
				result = str1;
			}
		}
		return result;
	}

	private static String get(Map<String, String> map, String name) {
		String str = null;
		if (map.get(name + ".png") != null)
			str = (String) map.get(name + ".png");
		else {
			if (map.get(name + ".jpg") != null) {
				str = (String) map.get(name + ".jpg");
			}
		}
		return str;
	}

	private static String getLanguageEnv() {
		Locale local = Locale.getDefault();
		String language = local.getLanguage();
		String country = local.getCountry().toLowerCase();
		if ("zh".equals(language)) {
			if ("cn".equals(country))
				language = "zh-CN";
			else if ("tw".equals(country)) {
				language = "zh-TW";
			}
		} else if ("pt".equals(language)) {
			if ("br".equals(country)) {
				language = "pt-BR";
			} else if ("pt".equals(country)) {
				language = "pt-PT";
			}
		}
		return language;
	}

	/**
	 * 获取.plist资源.
	 * 
	 * @param name
	 * @return
	 */
	public static String getRaw(String name) {
		return (String) raws.get(name + ".plist");
	}

	/**
	 * 把文件夹res下面的drawable和raw下面的文件路径全部缓存起来.
	 * 
	 * @param context
	 * @throws IOException
	 */
	public static void init(Context context) throws IOException {
		String[] arraystr = context.getAssets().list("res");
		int i = arraystr.length;
		for (int j = 0; j < i; j++) {
			String str1 = arraystr[j];
			String[] strings;
			HashMap drawable;
			if (str1.startsWith("drawable")) {
				strings = context.getAssets().list("res/" + str1);
				drawable = new HashMap();
				int n = strings.length;
				for (int i1 = 0; i1 < n; i1++) {
					String str3 = strings[i1];
					drawable.put(str3, "res/" + str1 + "/" + str3);
				}
				drawables.put(str1, drawable);
			} else if (str1.equals("raw")) {
				String[] lists = context.getAssets().list("res/" + str1);
				for (String str2 : lists)
					raws.put(str2, "res/" + str1 + "/" + str2);
			}
		}
	}

	/**
	 * 是否是中文.
	 * 
	 * @return
	 */
	public static boolean isLunarSetting() {
		String str = getLanguageEnv();
		return ((str != null) && ((str.trim().equals("zh-CN")) || (str.trim()
				.equals("zh-TW"))));
	}
}

作者 east

运维 2月 8,2021

shell监控日志关键字，并杀死有故障进程重启

在实际开发当中，会遇到很多程序运行一段时间出现故障，例如flume没有采集日志，写hbase的程序出现”Too many open files”或”session Time out”。除了把代码写健壮性，尽量能做到7*24小时零故障保障，还可以通过crontab来配置定时检测的脚本，分析程序的日志，根据关键来产生预警，或者来进行kill掉进程进行重启。

#bin/sh
is_equal(){
  if [ $1 eq '1' ]
  then
    echo $pid
    kill -9 $pid
    echo $?
  else exit
fi
//$7是gawk分割netstat -tunpl | grep 8083产生字符串的位置
my_pid=`netstat -tunpl | grep 8083 | gawk '{print $7}'`
cur_statu=`cat /app/my.log | tail -n 1 | grep 'Too many open files '|gawk -F 'Too many open files' '{print 1}'`
echo $cur_statu
is_equal $cur_statu $my_pid
sleep 5
nohup java -jar my.jar >/app/my.log 2>&1 &
echo 重启程序

作者 east

shardingsphere 2月 6,2021

shardingsphere4.0+Springboot+Mybatis+druid动态多数据源

首先Springboot+Mybatis+druid动态多数据源的配置是这样的

@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
@MapperScan(basePackages = "com.xxx.xxx.mapper")
@Import({DynamicDataSourceConfig.class})
public class BootApplication {

	public static void main(String[] args) {
		TimeZone.setDefault(TimeZone.getTimeZone("Asia/Shanghai"));
		SpringApplication.run(BootApplication.class, args);
	}

}

application.pro的关键配置如下：

spring:

datasource:
type: com.alibaba.druid.pool.DruidDataSource
druid:
# 配置监控服务器：http://ip:端口/druid/index.html
stat-view-servlet:
login-username: admin
login-password: kisen@123
reset-enable: false
url-pattern: /druid/*

  master: # 主数据源
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://167.1.6.163:53306/master?serverTimezone=Asia/Shanghai&useSSL=false&allowMultiQueries=true

  slave: # 从数据源
    #        driverClassName: org.postgresql.Driver
    #        username: postgres
    #        password: postgres
    #        url: jdbc:postgresql://192.168.30.22:5432/slave_db
    driverClassName: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://157.1.6.134:53

动态切换的配置文件如下：


import java.lang.annotation.*;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface DataSource {
    String name() default "";
}

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

@Aspect
@Component
public class DataSourceAspect {

    @Pointcut("@annotation(DataSource)")
    public void dataSourcePointCut() {

    }


    @Around("dataSourcePointCut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        MethodSignature signature = (MethodSignature) point.getSignature();
        Method method = signature.getMethod();


        DataSource dataSource = method.getAnnotation(DataSource.class);
        if(dataSource == null){
            DynamicDataSource.setDataSource("master");
        }else {
            System.out.println("dataSource.name()===="+dataSource.name());
            DynamicDataSource.setDataSource(dataSource.name());
        }

        try {
            return point.proceed();
        } finally {
            DynamicDataSource.clearDataSource();
        }
    }
}

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.datasource.lookup.AbstractRoutingDataSource;

public class DynamicDataSource  extends AbstractRoutingDataSource {

    private static final ThreadLocal<String> contextHolder = new ThreadLocal<>();

    private static Logger log = LoggerFactory.getLogger(DynamicDataSource.class);

    @Override
    protected Object determineCurrentLookupKey() {
     //   log.info("getDataSource()===================="+getDataSource());
        return getDataSource();
    }

    public static void setDataSource(String dataSource) {
        contextHolder.set(dataSource);
        log.info("切换到{"+dataSource+"}数据源");
        log.info("切换到{"+dataSource+"}数据源");
    }

    public static String getDataSource() {
        return contextHolder.get();
    }

    public static void clearDataSource() {
        contextHolder.remove();
    }
}

下面是最关键的地方，要对普通的druid多数据源动态切换做如下修改


import com.alibaba.druid.spring.boot.autoconfigure.DruidDataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;
import java.util.HashMap;
import java.util.Map;

@Configuration
public class DynamicDataSourceConfig {


    @Bean(name = "master")
    @ConfigurationProperties("spring.datasource.druid.master")
    public DataSource  masterDataSource(){
        return DruidDataSourceBuilder.create().build();
    }



    @Bean(name = "slave")
    @ConfigurationProperties("spring.datasource.druid.slave")
    public DataSource  anjianSlaveDataSource(){
        return DruidDataSourceBuilder.create().build();
    }

@Bean(name = "sharding")
public DataSource getShardingDataSource() throws SQLException {
		ShardingRuleConfiguration shardingRuleConfig = new ShardingRuleConfiguration();
 
		//  分库分表逻辑，在这里不做代码展示
 
		return ShardingDataSourceFactory.createDataSource(createDataSourceMap(), shardingRuleConfig,new ConcurrentHashMap(), properties);
	}

 public  Map<String, DataSource> createDataSourceMap() {
	   Map<String, DataSource> dataSourceMap = new HashMap<String, DataSource>(4);
	   // 配置第一个数据源
       DruidDataSource data1 = new DruidDataSource();
       data1.setDriverClassName("数据源驱动");
       data1.setUrl("数据库链接1");
       data1.setUsername("用户名");
       data1.setPassword("密码");
       dataSourceMap.put("data1 ", data1 );
 
       // 配置第二个数据源
       DruidDataSource data2 = new DruidDataSource();
       data2.setDriverClassName("数据源驱动");
       data2.setUrl("数据库链接2");
       data2.setUsername("用户名");
       data2.setPassword("密码");
       dataSourceMap.put("data2 ", data2 );
 
       // 配置第三个数据源
       DruidDataSource data3 = new DruidDataSource();
       data3.setDriverClassName("数据源驱动");
       data3.setUrl("数据库链接3");
       data3.setUsername("用户名");
       data3.setPassword("密码");
       dataSourceMap.put("data3", data3);
       
       // 配置第四个数据源
       DruidDataSource data4 = new DruidDataSource();
       data4.setDriverClassName("数据源驱动");
       data4.setUrl("j数据库链接4");
       data4.setUsername("用户名");
       data4.setPassword("密码");
       dataSourceMap.put("data4", data4);
       
       return dataSourceMap;
   }
 
}



    @Bean(name = "dynamicDataSource")
    @Primary
    public DynamicDataSource dynamicDataSource() {
        DynamicDataSource dynamicDataSource = new DynamicDataSource();
        // 默认数据源
        dynamicDataSource.setDefaultTargetDataSource(masterDataSource());
        // 配置多数据源
        Map<Object, Object> dsMap = new HashMap();
        dsMap.put("master", masterDataSource());
        dsMap.put("slave-anjian", anjianSlaveDataSource());

        dynamicDataSource.setTargetDataSources(dsMap);
        return dynamicDataSource;
    }

    /**
     * 配置@Transactional注解事物
     * @return
     */
    @Bean
    public PlatformTransactionManager transactionManager() {
        return new DataSourceTransactionManager(dynamicDataSource());
    }

}

作者 east

Elasticsearch 1月 31,2021

ES的内存xms和xmx设置不一致导致启动失败

问题背景与现象

ES启动失败：

1. 页面显示ES实例启动失败，查看详情是Xms和Xmx大小不一致；

ES的内存xms和xmx设置不一致导致启动失败

2. 查看ES后台日志，报错如下，初始化内存和最大内存不一致，导致启动失败

/var/log/Bigdata/elasticsearch/esnode1/elasticsearch_cluster.log

2018-12-11T17:21:49,670][INFO ][o.e.b.BootstrapChecks    ] [EsNode1] bound or publishing to a non-loopback address, enforcing bootstrap checks
[2018-12-11T17:21:49,673][ERROR][o.e.b.Bootstrap          ] [EsNode1] node validation exception
[1] bootstrap checks failed
[1]: initial heap size [536870912] not equal to maximum heap size [1073741824]; this can cause resize pauses and prevents mlockall from locking the entire heap
[2018-12-11T17:21:49,677][INFO ][o.e.n.Node               ] [EsNode1] stopping ...
[2018-12-11T17:21:49,708][INFO ][o.e.n.Node               ] [EsNode1] stopped
[2018-12-11T17:21:49,708][INFO ][o.e.n.Node               ] [EsNode1] closing ...
[2018-12-11T17:21:49,721][INFO ][o.e.n.Node               ] [EsNode1] closed

原因分析

如果JVM以不等的初始(Xms)和最大(Xmx)堆(heap)大小启动，则可能会在系统使用期间调整JVM堆的大小，因此可能会暂停。为了避免这些调整大小的停顿，需要使初始(Xms)堆(heap)大小等于最大Xms堆(heap)大小启动JVM。另外，启用了bootstrap.memory_lock，JVM将在启动时锁定堆(heap)的初始(Xms)大小。如果初始堆大小不等于最大堆大小，在重新调整大小之后，将不会将所有JVM堆锁定在内存中。

因此是ES的内核限制，要求ES的启动参数的初始(Xms)和最大(Xmx)内存相等。

作者 east

Elasticsearch 1月 31,2021

Elasticsearch(ES)运维常用命令

集群检查常用命令

1. 查询集群状态命令：

curl -XGET "http://ip:port/_cluster/health?pretty"

2. 查询Es全局状态：

curl -XGET "http://ip:port/_cluster/stats?pretty"

3. 查询集群设置

curl -XGET "http://ip:port/_cluster/settings?pretty"

4. 查看集群文档总数

curl -XGET "http://ip:port/_cat/count?v"

4. 查看集群文档总数

curl -XGET "http://ip:port/_cat/count?v"

5. 查看集群别名组

curl -XGET "http://ip:port/_cat/aliases"

6.查看当前集群索引分片信息

curl -XGET "http://ip:port/_cat/shards?v"   注：查看某一个索引可用shards/索引名?v

7.查看集群实例存储详细信息

curl -XGET "http://ip:port/_cat/allocation?v"

8.查看当前集群的所有实例

curl -XGET "http://ip:port/_cat/nodes?v"

9.查看某索引分片转移进度

curl -XGET "http://ip:port/_cat/recovery/索引名?v"

10.查看当前集群等待任务

curl -XGET "http://ip:port/_cat/pending_tasks?v"

11.查看集群写入线程池任务

curl -XGET "http://ip:port/_cat/thread_pool/bulk?v"

12.查看集群查询线程池任务

curl -XGET "http://ip:port/_cat/thread_pool/search?v"

13.查看分片未分配的原因

curl -XGET "http://127.0.0.1:24100/_cat/shards?v&h=index,shard,prirep,state,node,unassigned.reason" | grep UNASSIGNED

集群设置常用命令

1. 设置集群分片恢复参数

curl -XPUT   "http://ip:httpport/_cluster/settings"  -H  'Content-Type: application/json' -d' 
{ 
"transient": { 
   "cluster.routing.allocation.node_initial_primaries_recoveries":60,
   "cluster.routing.allocation.node_concurrent_recoveries":30,
   "cluster.routing.allocation.cluster_concurrent_rebalance":30
   } 
}'

2. 根据实例名称使EsNodeX实例下线：

curl -XPUT  "http://ip:httpport/_cluster/settings" -H 'Content-Type: application/json' -d' 
{ 
    "transient": { 
        "cluster.routing.allocation.exclude._name": "EsNode2@ip" 
     } 
}'

3. 根据ip使ES数据节点下线：

curl -XPUT  "http://ip:httpport/_cluster/settings" -H 'Content-Type: application/json' -d' 
{ 
    "transient": { 
          "cluster.routing.allocation.exclude._ip": "ip1,ip2,ip3" 
     } 
}'

4. 设置分片恢复过程中的最大带宽速度：

curl -XPUT "http://127.0.0.1:24100/_cluster/settings" -H 'Content-Type: application/json' -d
'{
 "transient":{
     "indices.recovery.max_bytes_per_sec":"500mb"
  }
}'

5. 重新分片为空的主分片

 curl -XPOST  "http://127.0.0.1:24100/_cluster/reroute?pretty" -H 'Content-Type:application/json' -d '
{
   "commands": [{
                "allocate_empty_primary": {		
                                      "index": "indexname",			
                                      "shard": 2,
                                      "node": "EsNode1@81.20.5.24",
                                      "accept_data_loss":true
                                           }
               }]
}'

6. 重新分配主分片，会尝试将过期副本分片分片为主。

curl -XPOST "http://127.0.0.1:24100/_cluster/reroute?pretty" -H 'Content-Type:application/json' -d '
{
   "commands": [{
               "allocate_stale_primary": {
                                        "index": "index1",
                                        "shard": 2,
			                "node": "EsNode1@189.39.172.103",
                                        "accept_data_loss":true
                                          }
               }]
}'

7. 清理ES所有缓存

curl -XPOST "http://ip:port/_cache/clear"

8.关闭分片自动平衡

curl -XPUT
 "http://ip:port/_cluster/settings" -H 'Content-Type:application/json' -d '
{
   "transient":{   "cluster.routing.rebalance.enable":"none" }
}'

9.手动刷新未分配的分片

curl -XPOST "http://127.0.0.1:24100/_cluster/reroute?retry_failed=true"

索引查看常用命令

1. 查询索引mapping和settings

curl -XGET_{--tlsv1.2  --negotiate -k -u : 'https://ip:port/my_index_name?pretty'}

2. 查询索引settings

curl -XGET--tlsv1.2  --negotiate -k -u : 'https://ip:port/my_index_name/_settings?pretty'

3.查看分片未分配详细命令

curl -XGET "http://127.0.0.1:24100/_cluster/allocation/explain?pretty" -H 'Content-Type:application/json' -d '
{"index": "indexname","shard": 17,"primary": true}'

4.修改索引只读字段属性为null，放开写入

curl -XPUT  "http://127.0.0.1:24100/*/_settings" -H 'Content-Type: application/json' -d '{"index.blocks.read_only_allow_delete": null}'

索引设置常用命令

1.关闭索引

curl -XPOST 'http://ip:port/my_index/_close?pretty'

2.打开索引

curl -XPOST 'http://ip:port/my_index/_open?pretty'

3.修改索引刷新时间：

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"refresh_interval" : "60s"}'

4.修改translog文件保留时长，默认为12小时

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"index.translog.retention.age" : "30m"}'

5.设置索引副本：

curl -XPUT 'http://ip:port/my_index/_settings?pretty' -H 'Content-Type: application/json' -d'{"number_of_replicas" : 1}'

6.执行refresh，将内存数据刷新到磁盘缓存

curl -XPOST 'http://ip:port/myindex/_refresh'

7.执行flush，将磁盘缓存刷新到文件系统

curl -XPOST 'https://ip:port/myindex/_flush'

8.执行synced flush，生成syncid

curl -XPOST  'http://ip:port/_flush/synced'

9. 强制执行段合并

curl -XPOST 'http://ip:httpport/myindex/_forcemerge?only_expunge_deletes=false&max_num_segments=1&flush=true&pretty'

10.设置索引在每个esnode上的分片个数

curl -XPUT 'http://ip:httpport/myindex/_settings?pretty' -H 'Content-Type: application/json' -d'{"index.routing.allocation.total_shards_per_node" : "2"}'

11. 配置控制段合并的refresh、merge线程数等

curl -XPUT  "http://ip:port/my_index/_settings?pretty" -H 'Content-Type: application/json' -d'
{"refresh_interval": "60s",
 "merge":{"scheduler"：{"max_merge_count" : "100",
                        "max_thread_count" : "1"},
          "policy":{"segments_per_tier" : "100",
                    "floor_segment" : "1m",
                    "max_merged_segment" : "2g"}
          }
}'

12.设置索引的刷新时间和translog配置参数

注意：设置translog参数，必须先关闭索引，设置完成后再打开

*代表设置所有索引，如果要设置具体某个索引，可以将*替换为具体的索引名称

curl -XPUT "http://ip:httpport/*/_settings" -H 'Content-Type: application/json' -d'
{ "index": 
          { "refresh_interval" : "60s",
            "translog": 
                      { "flush_threshold_size": "1GB", "sync_interval": "120s", "durability": "async" 
                      } 
          } 
}'

13.限制每个索引在每个实例上的分片个数

curl -XPUT  'http://ip:httpport/myindex/_settings?pretty' -H 'Content-Type:application/json' -d '{"index.routing.allocation.total_shards_per_node":"2"}'

实例检查常用命令

1.查看实例安装插件

curl -XGET "http://ip:port/_cat/aliases"

2.查询指定ES实例的jvm参数：

curl -XGET 'http://ip:port/_nodes/EsNode1*/stats/jvm?pretty'
curl -XGET 'http://ip:port/_nodes/EsNode1@12.40.16.156/stats/jvm?pretty'

作者 east

视频直播服务器设计原则